OpenAI GPT API

OpenAIs API war die erste grosse LLM-API und ist bis heute der de-facto Standard - viele Libraries sind “OpenAI-compatible” (selbst nicht-OpenAI-Modelle wie Ollama oder DeepSeek). Wer GPT kann, kann meist auch alles andere.

API-Key holen

Registriere dich auf platform.openai.com
Erstelle einen API-Key unter API Keys
Lade Guthaben auf (oder Credit-Karte hinterlegen)

Als Environment-Variable:

export OPENAI_API_KEY="sk-..."

Python-Setup

pip install openai

Erste Anfrage

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Was ist Closure in JavaScript?"}
    ],
)

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

Die Grundbausteine

`messages`

Das Konzept ist sehr aehnlich zu Claude - drei Rollen:

messages=[
    {"role": "system",    "content": "Du bist ein hilfreicher Code-Tutor."},
    {"role": "user",      "content": "Erklaere Promises."},
    {"role": "assistant", "content": "Ein Promise ist..."},
    {"role": "user",      "content": "Und wie funktioniert async/await?"},
]

Unterschied zu Claude: system ist eine eigene Message in OpenAIs Format (nicht ein separater Parameter).

Modell waehlen

Die aktuelle OpenAI-Familie umfasst ca.:

Modell	Staerke
`gpt-5`	Top-Reasoning
`gpt-4o`	Multimodal (Text, Bild, Audio)
`gpt-4o-mini`	Schnell & guenstig
`o4-mini`	Reasoning-optimiert

Die Namen aendern sich staendig - check die Docs.

Streaming

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Zaehle von 1 bis 5."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
print()

JSON Mode - strukturierte Ausgabe

Eines der nuetzlichsten Features:

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Antworte immer als JSON."},
        {"role": "user", "content": "Extrahiere Name und Alter: 'Anna ist 28 Jahre alt'"}
    ],
    response_format={"type": "json_object"},
)

import json
daten = json.loads(response.choices[0].message.content)
print(daten)
# {"name": "Anna", "alter": 28}

Fuer noch mehr Sicherheit: Structured Outputs mit JSON-Schema:

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "alter": {"type": "integer"}
                },
                "required": ["name", "alter"]
            }
        }
    }
)

Das Modell kann nicht mehr invalides JSON liefern - die API zwingt das Schema.

Function Calling (Tool Use)

tools = [
    {
        "type": "function",
        "function": {
            "name": "wetter_abfragen",
            "description": "Aktuelles Wetter fuer eine Stadt",
            "parameters": {
                "type": "object",
                "properties": {
                    "stadt": {"type": "string"}
                },
                "required": ["stadt"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Wie ist das Wetter in Berlin?"}],
    tools=tools,
)

msg = response.choices[0].message
if msg.tool_calls:
    for call in msg.tool_calls:
        print(f"{call.function.name}({call.function.arguments})")

Das Modell antwortet nicht direkt - es fordert auf, die Funktion aufzurufen. Du fuehrst sie aus und schickst das Ergebnis zurueck.

Vision - Bilder verstehen

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Was ist auf dem Bild?"},
            {"type": "image_url", "image_url": {
                "url": "https://example.com/foto.jpg"
            }}
        ]
    }],
)

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

Du kannst auch Base64-kodierte Bilder uebergeben - praktisch fuer lokale Dateien.

TypeScript

npm install openai

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [
    { role: "user", content: "Was ist TypeScript?" }
  ],
});

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

Die Node.js-SDK ist funktionsgleich zur Python-Variante.

Chatbot mit Historie

from openai import OpenAI

client = OpenAI()
history = [
    {"role": "system", "content": "Du bist ein freundlicher Assistent. Antworte auf Deutsch."}
]

while True:
    user = input("Du: ").strip()
    if user.lower() == "exit":
        break

    history.append({"role": "user", "content": user})

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

    answer = response.choices[0].message.content
    history.append({"role": "assistant", "content": answer})

    print(f"GPT: {answer}\n")

Kosten verstehen

Jede Response enthaelt usage:

print(response.usage)
# CompletionUsage(prompt_tokens=42, completion_tokens=187, total_tokens=229)

Preise findest du auf openai.com/pricing. Fuer typische Prototypen: wenige Euro.

Retries und Error Handling

Produktive Apps brauchen Retries:

from openai import RateLimitError, APIError
import time

def call_mit_retry(max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
        except APIError as e:
            print(f"API-Fehler: {e}")
            raise

response = call_mit_retry(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hi"}]
)

OpenAI vs. Claude - wann was?

OpenAI / GPT: Schnell, grosse Community, starker JSON-Support, gute Libraries
Anthropic / Claude: Starkes Reasoning, guenstiges Caching, lange Kontexte, oft bessere Code-Qualitaet

In der Praxis probierst du beide - oft ergaenzen sie sich.

Kompatible Alternativen

Die OpenAI-API ist so populaer, dass viele Tools sie “sprechen”:

# Ollama lokal mit gleicher SDK
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

response = client.chat.completions.create(
    model="llama3",
    messages=[...]
)

So kannst du lokal Modelle testen, ohne den Code zu aendern.

Zusammenfassung

chat.completions.create(model, messages) als Grundform
System-Message ist Teil der Messages-Liste (anders als Claude)
Streaming mit stream=True
JSON Mode und Structured Outputs fuer parsebare Ausgabe
Vision via Bild-URLs in der Message
Tool Use / Function Calling fuer Agenten
OpenAI-API als “lingua franca” - auch lokale Modelle nutzen das gleiche Protokoll

Im naechsten Kapitel: Embeddings und RAG - Wissen hinzufuegen, das nicht im Modell steckt.