OpenAI API Komplettanleitung 2025 – Von Setup bis Production

pip install openai

npm install openai

from openai import OpenAI

client = OpenAI(api_key="sk-proj-...")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": "Was ist die Hauptstadt von Deutschland?"}
    ],
    max_tokens=100,
    temperature=0.7
)

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

import OpenAI from "openai";

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

const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [
    { role: "system", content: "Du bist ein hilfreicher Assistent." },
    { role: "user", content: "Was ist die Hauptstadt von Deutschland?" }
  ],
  max_tokens: 100,
  temperature: 0.7
});

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

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-proj-..." \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello"}],
    "max_tokens": 100
  }'

# Deterministisch
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "2+2="}],
    temperature=0.0
)
# Output: "4"

# Kreativ
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Schreibe eine Geschichte über einen Drachen"}],
    temperature=1.5
)
# Output: Unvorhersehbare, kreative Story

# Schlecht: max_tokens zu hoch
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Was ist 2+2?"}],
    max_tokens=4000  # Verschwendung, Antwort ist nur 1 Token
)

# Gut: max_tokens angemessen
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Was ist 2+2?"}],
    max_tokens=10
)

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Erzähle eine Geschichte"}],
    stream=True
)

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

const stream = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Erzähle eine Geschichte" }],
  stream: true
});

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

import requests

def get_weather(location):
    # Simuliert Wetter-API
    return {"temperature": 22, "condition": "sunny"}

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    }
]

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

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

# GPT entscheidet: Ich muss get_weather aufrufen
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)

# Führe Funktion aus
result = get_weather(arguments["location"])

# Sende Ergebnis zurück an GPT
messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps(result)
})

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

print(final_response.choices[0].message.content)
# Output: "In Berlin ist es aktuell 22°C und sonnig."

messages = [
    {"role": "user", "content": """
    Ich brauche eine Zusammenfassung von diesem Text. 
    Bitte lies ihn sorgfältig und gib mir die wichtigsten Punkte.
    Achte darauf, dass du nichts Wichtiges vergisst.
    
    Text: ...
    """}
]

messages = [
    {"role": "user", "content": "Fasse zusammen: ..."}
]

messages = [
    {"role": "user", "content": "Du bist ein Experte für Marketing. Schreibe einen Blog-Post über SEO..."}
]

messages = [
    {"role": "system", "content": "Du bist ein Marketing-Experte."},
    {"role": "user", "content": "Schreibe einen Blog-Post über SEO..."}
]

import redis

cache = redis.Redis()

def get_completion(prompt):
    cached = cache.get(prompt)
    if cached:
        return cached.decode()
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    
    result = response.choices[0].message.content
    cache.set(prompt, result, ex=86400)  # 24h Cache
    return result

# Erstelle Batch-Job
batch = client.batches.create(
    input_file_id="file-abc123",
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

# Ergebnisse nach max. 24h abholen
result = client.batches.retrieve(batch.id)

from openai import RateLimitError
import time

def call_with_retry(messages, max_retries=3):
    for i in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gpt-4o",
                messages=messages
            )
        except RateLimitError:
            if i < max_retries - 1:
                time.sleep(2 ** i)  # Exponential Backoff
            else:
                raise

api_key = "sk-proj-abc123..."  # Hardcoded

import os
api_key = os.getenv("OPENAI_API_KEY")

from openai import OpenAIError, APIError, RateLimitError

try:
    response = client.chat.completions.create(...)
except RateLimitError:
    # Warten und retry
    pass
except APIError as e:
    # Log error, alert team
    logger.error(f"OpenAI API Error: {e}")
except OpenAIError as e:
    # Catch-all für andere Fehler
    pass

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def call_gpt(prompt):
    start = time.time()
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )
    
    latency = time.time() - start
    tokens = response.usage.total_tokens
    cost = tokens * 0.00001  # Vereinfachte Berechnung
    
    logger.info(f"GPT Call: {latency:.2f}s, {tokens} tokens, ${cost:.4f}")
    
    return response.choices[0].message.content

def sanitize_input(user_input):
    # Entferne System-Keywords
    dangerous = ["ignore previous", "system:", "assistant:", "override"]
    for keyword in dangerous:
        if keyword.lower() in user_input.lower():
            return "[BLOCKED]"
    return user_input

user_input = sanitize_input(request.form["message"])

moderation = client.moderations.create(input=user_input)

if moderation.results[0].flagged:
    # Input enthält unangemessenen Content
    return "Your message was flagged"

# Abrufen der aktuellen Usage (erfordert Organization-Admin)
usage = client.usage.retrieve(date="2025-02-08")

print(f"Total Kosten heute: ${usage.total_cost}")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    max_tokens=1000  # Erhöhen
)