Bildgenerierung mit anderen API-Tools kombinieren

Update vom 2. November 2026 — Bildmodelle. Das Modell, für das dieser Kurs ursprünglich geschrieben wurde, gpt-image-1, wurde am 23. Oktober 2026 eingestellt. gpt-image-1.5, gpt-image-1-mini und chatgpt-image-latest werden am 1. Dezember 2026 eingestellt. Die Beispiele verwenden nun gpt-image-2.5-sunburst, das die höchste Präzision für Bearbeitungen bietet; gpt-image-2.5-flare ist für die Standardgenerierung schneller. Beide Modelle unterstützen zudem die Qualitätsstufen xhigh und max. GPT-Bildmodelle geben Bilder stets im Base64-Format zurück: Der Parameter response_format von älteren DALL·E-Modellen wird nicht unterstützt und aus dem Code entfernt. Quelle: Bildgenerierung (OpenAI).

Bildgenerierung mit anderen API-Tools kombinieren

Isoliert betrachtet ist die Bildgenerierung ein Handwerkswerkzeug: Sie schreiben einen Prompt und erhalten eine Datei. Ihre wahre Kraft entfaltet sich, wenn sie zu einem Schritt in einer automatisierten Kette wird – ein Sprachmodell, das den Prompt schreibt, eine Vision-Analyse, die ein Referenzbild beschreibt, oder ein Speichermedium, das das Ergebnis veröffentlicht. In dieser Lektion zeigen wir Ihnen, wie Sie diese Bausteine miteinander verbinden.

Lassen Sie ein Sprachmodell den Prompt schreiben

Ihre Nutzer oder Kollegen schreiben keine visuellen Prompts; sie schreiben Briefe. „Ich brauche ein Bild für einen Artikel über KI im Gesundheitswesen, futuristisch, aber menschlich” enthält keine Angaben zu Komposition, Beleuchtung oder Farbpalette. Anstatt sie zu bitten, das Vokabular aus der vorherigen Lektion zu lernen, setzen Sie ein Sprachmodell ein, um die Übersetzung zu übernehmen. Weisen Sie ihm in der Systemnachricht die Rolle des Kunstleiters zu und verlangen Sie, dass es die spezifischen Ebenen des Prompts erstellt, mit strengen Anweisungen, nichts anderes auszugeben. Andernfalls erhalten Sie eine höfliche Erklärung, die Sie dann an GPT Image senden müssten.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Zweistufiger Pipeline:
    1. Ein LLM generiert den optimalen visuellen Prompt
    2. GPT Image erstellt das Bild
    """
    # Schritt 1: Generieren Sie den visuellen Prompt mit einem LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "Sie sind ein erfahrener Kunstleiter. "
                    "Basierend auf einem Brief generieren Sie einen detaillierten Prompt für ein "
                    "Bildgenerierungsmodell. Beziehen Sie sich auf: Sujet, Komposition, Beleuchtung, "
                    "Stil, Perspektive, Farbpalette. "
                    "Antworten Sie nur mit dem Prompt, ohne Erklärung."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Generierter Prompt: {visual_prompt[:100]}...")

    # Schritt 2: Generieren Sie das Bild
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Bild generiert: {output}")
    return visual_prompt


prompt = text_to_image(
    "Ich brauche ein Bild für einen Artikel über künstliche Intelligenz "
    "im Gesundheitswesen. Futuristisch, aber menschlich.",
    "ai_health.png"
)

Einen Artikel von Anfang bis Ende illustrieren

Ein Feature-Artikel benötigt ein Coverbild und eine Illustration pro Abschnitt. Diese Bilder müssen zusammenhängend aussehen, ohne identisch zu sein. Die Funktion illustrate_article wendet diese Logik an, indem sie den Stil in jeden Prompt wieder einfügt und den Artikeltitel jedes Mal wiederholt, was der gesamten Reihe thematische Einheit verleiht. Zwei kostensparende Details verdienen Aufmerksamkeit: Das Cover wird in high-Qualität generiert, da es von allen gesehen wird und oft geteilt wird, während Abschnittsillustrationen in medium bleiben, da sie kleiner und weiter unten auf der Seite angezeigt werden. Für die fünf Abschnitte in diesem Beispiel über KI im Recruiting schneidet dieser Kompromiss die Rechnung, ohne dass der Leser etwas bemerkt.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Generiert eine Kopf-Illustration + eine pro Abschnitt.
    """
    results = []

    # Cover-Bild
    header_prompt = (
        f"Cover-Bild für einen Artikel mit dem Titel \"{title}\", "
        f"{style} Stil, panoramische Komposition, "
        "kein Text im Bild, professionell"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Kopfzeile: {path}")

    # Abschnittsillustrationen
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration für den Abschnitt \"{section}\" "
            f"eines Artikels über \"{title}\", "
            f"{style} Stil, rechteckiges Format, "
            "konzeptionelle Illustration ohne Text"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Abschnitt {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Wege, wie KI das Recruiting transformiert",
    sections=[
        "Automatische Lebenslauf-Screening",
        "KI-analyzierte Video-Interviews",
        "Intelligente Kandidaten-Arbeitsplatz-Zuordnung",
        "Verringerung von Recruiting-Voreingenommenheit",
        "Personalisierte Onboarding",
    ],
    style="3D isometrische Illustration, blaue und violette Töne",
    output_dir="."
)

Beschreiben Sie ein Bild, um es anders zu regenerieren

Wie erhalten Sie eine Winter-Version einer Sommerlandschaft, wenn Sie nur die Datei haben, keine Maske und keine Bearbeitungswerkzeuge? Gehen Sie über die Sprache. Das Modell analysiert das Bild mit seiner Vision und erstellt eine Beschreibung, die präzise genug ist, um als Rekonstruktions-Prompt zu dienen – Sujet, Komposition, Beleuchtung, Farben, Stil, Perspektive, Stimmung. Sie fügen dann Ihre Änderungsinstruktion an diese Beschreibung an. Das Generierungsmodell erhält einen vollständigen Textprompt, bei dem nur die Jahreszeit geändert wurde, und Sie erhalten ein Bild, das mit dem Original kohärent ist, anstatt etwas Unverwandtes. Dies ist auch der zuverlässigste Weg, um die visuelle Identität eines Referenzbildes zu reproduzieren, das Sie nicht direkt bearbeiten können.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analysiert ein Bild mit GPT Vision
    2. Generiert eine Variante basierend auf der Analyse
    """
    # Schritt 1: Bild analysieren
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Beschreiben Sie dieses Bild detailliert, damit ein Bildgenerierungsmodell "
                            "es treu reproduzieren kann. Beziehen Sie sich auf: Sujet, Komposition, "
                            "Beleuchtung, Farben, Stil, Perspektive, Stimmung. Seien Sie sehr präzise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Analyse: {description[:150]}...")

    # Schritt 2: Generieren Sie eine modifizierte Variante
    variant_prompt = f"{description}. Geforderte Änderung: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Variante generiert: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Ändern Sie die Jahreszeit von Sommer zu Winter, mit Schnee auf Dächern und Bäumen",
    "winter_landscape.png"
)

Verarbeiten Sie große Mengen in Batches

Die Generierung von fünf Produktvisualisierungen in Serie dauert Minuten; die sequentielle Generierung von fünfhundert dauert die ganze Nacht und bricht beim ersten Netzwerk-Hickups. Die folgende Einrichtung löst beide Probleme. Jede Aufgabe ist ein eigenständiges Dictionary, das ihre ID, den Prompt, die Ausgabedatei und die Einstellungen trägt. Die Worker-Funktion umhüllt den Aufruf in einem try-Block, der einen Status zurückgibt, anstatt die gesamte Batch-Verarbeitung zu stürzen: Eine abgelehnte Generierung bringt die anderen vierhundertneunundneunzig nicht mehr zum Erliegen. Der ThreadPoolExecutor parallelisiert dann die Ausführung, aber mit einem bewusst niedrigen max_workers – drei in diesem Beispiel –, weil die Engstelle nicht Ihre Maschine ist, sondern die API-Quoten. Der finale Bericht zählt Erfolge und Fehler, damit Sie wissen, was Sie erneut versuchen müssen.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Generiert ein einzelnes Bild aus einer Aufgabe."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Führt eine Batch-Generierung mit kontrollierter Parallelität aus."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Bericht
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFertig: {ok} ok, {errors} Fehler von {len(tasks)} Aufgaben")

    return results


# Definieren Sie eine Batch von Aufgaben
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-Commerce-Produktfotografie: {product}, weißer Hintergrund, Studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "Rose-Gold-Uhr",
        "Aviator-Sonnenbrillen",
        "Geflochtene Lederarmband",
        "Solitär-Diamantring",
        "Kultivierte Perlenkette",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Veröffentlichen Sie direkt im Speicher

Das Schreiben der PNG-Datei auf die Festplatte der Maschine, auf der das Skript läuft, macht nur in der Entwicklung Sinn. In der Produktion muss das Bild dort landen, wo Ihre Seite es abrufen kann, und ein Umweg über das lokale Dateisystem wird zu einer unnötigen Fehlerquelle. Das b64_json-Format eignet sich gut für diese Entfernung: Die entzifferten Bytes werden in ein BytesIO-Objekt eingewickelt und direkt in den Bucket geschoben, mit einem expliziten ContentType – ohne welchen würden Browser das Bild herunterladen statt anzuzeigen. Die Funktion gibt die öffentliche URL zurück, was Ihr CMS tatsächlich benötigt.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Generiert ein Bild und lädt es direkt in S3 hoch."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    image_data = base64.b64decode(response.data[0].b64_json)

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Bild in S3 gespeichert: {url}")
    return url


# Beispiel
url = generate_and_store_s3(
    "App-Symbol für Mobilgeräte: offenes Buch mit Sternen, flaches Design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Was hält eine Pipeline aufrecht

Die fünf Pipelines in dieser Lektion teilen sich die gleiche Konstruktionshygiene. Jeder Schritt tut eine Sache, sodass Sie das Prompt-Schreiben oder den Speicher ersetzen können, ohne den Rest zu berühren. Jeder Schritt behandelt seine eigenen Fehler; andernfalls würde eine Moderationsablehnung in der Mitte eines Batches die gesamte Kette zum Erliegen bringen – genau das verhindert der try-Block in generate_one_image. Parallelität bleibt gedrosselt, um Rate-Limits zu respektieren, und an dieser Stelle kostet Vorsicht weniger als die Wiederherstellung nach einer vorübergehenden Sperrung.

Zwei weniger sichtbare, aber ebenso entscheidende Gewohnheiten bleiben. Protokollieren Sie die tatsächlich gesendeten Prompts, insbesondere wenn sie von einem Sprachmodell geschrieben wurden: Ohne dieses Protokoll wird ein Bild, das Sie lieben, bei der zweiten Ausführung nicht reproduzierbar. Und cachen Sie Ergebnisse, wann immer derselbe Prompt zurückgegeben werden könnte, was die nächste Lektion in ein vollständiges System formalisiert.

Montieren Sie nun Ihre eigene vollständige Kette: Nehmen Sie einen Artikeltitel als Eingabe, bitten Sie ein Sprachmodell um drei Beschreibungen relevanter Visualisierungen, generieren Sie die drei Bilder parallel und erstellen Sie eine Zusammenfassungs-JSON-Datei, die jeden Prompt mit seiner Datei verknüpft. Sie werden dann alles haben, was benötigt wird, um einen gesamten Blog ohne manuelle Intervention zu illustrieren.