Python: API-Calls zur Content-Generierung

Überblick

Automatisiere Content-Generierung für deine programmatischen SEO-Seiten mit Python API-Calls. Dieses Beispiel zeigt wie du KI-APIs (OpenAI, xAI) aufrufst um Content im großen Maßstab zu generieren mit korrektem Error-Handling und Retry-Logik.

Der Code

import os
import json
import requests
import time
from typing import Optional

# Konfiguration aus Environment
OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
OPENAI_API_URL = 'https://api.openai.com/v1/chat/completions'
OPENAI_API_MODEL = os.environ.get('OPENAI_API_MODEL', 'gpt-4o-mini')

def call_openai_api(messages: list, max_retries: int = 3) -> Optional[dict]:
    """
    Rufe OpenAI API mit Retry-Logik und Error-Handling auf.
    Gibt geparste JSON-Response oder None bei Fehler zurück.
    """
    headers = {
        "Authorization": f"Bearer {OPENAI_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": OPENAI_API_MODEL,
        "messages": messages,
        "temperature": 0.7,
        "max_tokens": 16000
    }
    
    for attempt in range(max_retries):
        try:
            response = requests.post(
                OPENAI_API_URL,
                headers=headers,
                json=payload,
                timeout=180  # 3 Min Timeout
            )
            response.raise_for_status()
            
            result = response.json()
            content = result["choices"][0]["message"]["content"]
            
            # Response bereinigen - Markdown-Code-Blöcke entfernen falls vorhanden
            content = content.strip()
            if content.startswith("```json"):
                content = content[7:]
            if content.startswith("```"):
                content = content[3:]
            if content.endswith("```"):
                content = content[:-3]
            content = content.strip()
            
            # JSON parsen
            return json.loads(content)
            
        except json.JSONDecodeError as e:
            print(f"JSON-Parse-Fehler (Versuch {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Exponentielles Backoff
                
        except requests.exceptions.RequestException as e:
            print(f"API-Fehler (Versuch {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
    
    return None

def generate_content(entity_data: dict, prompt_template: str) -> Optional[dict]:
    """
    Generiere Content für eine einzelne Entität mit KI-API.
    """
    messages = [
        {"role": "system", "content": "Du bist ein Experten-SEO-Content-Writer."},
        {"role": "user", "content": prompt_template.format(**entity_data)}
    ]
    
    return call_openai_api(messages)

# Beispiel-Nutzung
entity = {
    "name": "Notion",
    "category": "Productivity Tools",
    "features": ["Notes", "Databases", "Collaboration"]
}

prompt = """Schreibe SEO-optimierten Content über {name}, ein {category}.
Füge diese Features ein: {features}.
Gib JSON zurück mit: title, meta_description, content_html.
"""

result = generate_content(entity, prompt)
if result:
    print(f"Generiert: {result.get('title')}")
else:
    print("Content-Generierung fehlgeschlagen")

Wichtige Features

• Retry-Logik: Exponentielles Backoff bei Fehlern
• Error-Handling: Graceful Handling von API-Fehlern und JSON-Parsing
• Response-Bereinigung: Entfernt Markdown-Code-Blöcke aus KI-Responses
• Timeout-Schutz: Verhindert hängende Requests
• Environment-Variablen: Sichere API-Key-Verwaltung

Skalierungs-Tipps

• Nutze async/await für gleichzeitige Requests
• Implementiere Rate Limiting um API-Limits zu respektieren
• Cache Responses für ähnliche Entitäten
• Batch-Verarbeitung für mehrere Entitäten
• Überwache API-Nutzung und Kosten