Gemini-Bildmodelle verwenden

Diese Anleitung zeigt, wie Sie Gemini-Bildmodelle über CometAPI mit dem Google Gen AI SDK verwenden. Sie behandelt:

Text-zu-Bild-Generierung
Bild-zu-Bild-Bearbeitung
Komposition mehrerer Bilder
Generierte Bilder speichern

Base URL: https://api.cometapi.com
Installieren Sie das SDK: pip install google-genai (Python) oder npm install @google/genai (Node.js)

Einrichtung

Initialisieren Sie den Client mit der Base URL von CometAPI:

from google import genai
from google.genai import types
import os

COMETAPI_KEY = os.environ["COMETAPI_KEY"]

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=COMETAPI_KEY,
)

import { GoogleGenAI } from "@google/genai";

const COMETAPI_KEY = process.env.COMETAPI_KEY;

const ai = new GoogleGenAI({
  apiKey: COMETAPI_KEY,
  httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});

package main

import (
	"context"
	"os"
	"google.golang.org/genai"
)

func main() {
	ctx := context.Background()
	apiKey := os.Getenv("COMETAPI_KEY")

	client, _ := genai.NewClient(ctx, &genai.ClientConfig{
		APIKey:  apiKey,
		Backend: genai.BackendGeminiAPI,
		HTTPOptions: genai.HTTPOptions{
			BaseURL: "https://api.cometapi.com",
		},
	})
	// use client below...
}

Text-to-image-Generierung

Erzeugen Sie ein Bild aus einem Text-Prompt und speichern Sie es in einer Datei.

from google import genai
from google.genai import types
from PIL import Image
import os

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=os.environ.get("COMETAPI_KEY"),
)

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents="Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
    ),
)

final_image = None
for part in response.parts:
    if getattr(part, "thought", False):
        continue
    if part.text is not None:
        print(part.text)
    elif part.inline_data is not None:
        final_image = part.as_image()

if final_image:
    final_image.save("generated_image.png")
    print("Image saved to generated_image.png")

import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";

const ai = new GoogleGenAI({
  apiKey: process.env.COMETAPI_KEY,
  httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});

const response = await ai.models.generateContent({
  model: "gemini-3.1-flash-image-preview",
  contents: "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme",
  config: { responseModalities: ["TEXT", "IMAGE"] },
});

let finalImagePart;
for (const part of response.candidates[0].content.parts) {
  if (part.thought === true) {
    continue;
  }
  if (part.text) {
    console.log(part.text);
  }
  if (part.inlineData) {
    finalImagePart = part;
  }
}

if (finalImagePart) {
  const buffer = Buffer.from(finalImagePart.inlineData.data, "base64");
  fs.writeFileSync("generated_image.png", buffer);
  console.log("Image saved to generated_image.png");
}

curl -s -X POST \
  "https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{"text": "Create a picture of a nano banana dish in a fancy restaurant with a Gemini theme"}]
    }],
    "generationConfig": {
      "responseModalities": ["TEXT", "IMAGE"]
    }
  }'

Speichern Sie den endgültigen Bildteil: Die Bilddaten befinden sich in candidates[0].content.parts, die Text- und/oder Bildteile enthalten können. Gemini-Bildmodelle können auch Zwischen-Thought-Teile vor dem endgültigen Bild zurückgeben, insbesondere wenn Sie sowohl Text als auch Bilder anfordern oder die Thinking-Ausgabe explizit aktivieren. Speichern Sie nicht blind das erste inlineData; überspringen Sie Teile, bei denen thought den Wert true hat, und speichern Sie dann den letzten verbleibenden Bildteil. Typische Antwort nur mit dem endgültigen Bild:

{
  "candidates": [{
    "content": {
      "parts": [
        { "text": "Here is your image..." },
        {
          "inlineData": {
            "mimeType": "image/png",
            "data": "<base64-encoded-image>"
          }
        }
      ]
    }
  }]
}

Antwort mit einem Textteil, einem Zwischenbild für Thought und dem endgültigen Bild:

{
  "candidates": [{
    "content": {
      "role": "model",
      "parts": [
        { "text": "Here is your image..." },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "<base64-encoded-intermediate-image>"
          },
          "thought": true
        },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "<base64-encoded-final-image>"
          },
          "thought": false,
          "thoughtSignature": "<signature>"
        }
      ]
    },
    "finishReason": "STOP"
  }]
}

Verwenden Sie diese Parsing-Regel für jede Gemini-Bildantwort:

const imageParts = response.candidates[0].content.parts.filter(
  (part) => part.inlineData && part.thought !== true,
);
const finalImagePart = imageParts.at(-1);

Bild-zu-Bild-Generierung

Laden Sie ein Eingabebild hoch und transformieren Sie es mit einem Text-Prompt.

from google import genai
from google.genai import types
from PIL import Image
import os

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=os.environ.get("COMETAPI_KEY"),
)

# Load the source image
source_image = Image.open("source.jpg")

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=["Transform this into a watercolor painting", source_image],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
    ),
)

final_image = None
for part in response.parts:
    if getattr(part, "thought", False):
        continue
    if part.text is not None:
        print(part.text)
    elif part.inline_data is not None:
        final_image = part.as_image()

if final_image:
    final_image.save("watercolor_output.png")

import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";

const ai = new GoogleGenAI({
  apiKey: process.env.COMETAPI_KEY,
  httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});

const imageData = fs.readFileSync("source.jpg").toString("base64");

const response = await ai.models.generateContent({
  model: "gemini-3.1-flash-image-preview",
  contents: [
    { text: "Transform this into a watercolor painting" },
    { inlineData: { mimeType: "image/jpeg", data: imageData } },
  ],
  config: { responseModalities: ["TEXT", "IMAGE"] },
});

const imageParts = response.candidates[0].content.parts.filter(
  (part) => part.inlineData && part.thought !== true,
);
const finalImagePart = imageParts.at(-1);

if (finalImagePart) {
  fs.writeFileSync("watercolor_output.png", Buffer.from(finalImagePart.inlineData.data, "base64"));
}

curl -s -X POST \
  "https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        { "text": "Transform this into a watercolor painting" },
        { "inline_data": { "mime_type": "image/jpeg", "data": "<base64-encoded-source-image>" } }
      ]
    }],
    "generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
  }'

Das Python SDK akzeptiert PIL.Image-Objekte direkt — keine manuelle Base64-Kodierung erforderlich.
Fügen Sie nicht das Präfix data:image/jpeg;base64, ein, wenn Sie rohe Base64-Strings übergeben.

Multi-image-Komposition

Erzeuge ein neues Bild aus mehreren Eingabebildern. CometAPI unterstützt zwei Ansätze:

Methode 1: Einzelnes Collage-Bild

Kombiniere mehrere Quellbilder zu einer Collage und beschreibe dann die gewünschte Ausgabe.

from google import genai
from google.genai import types
from PIL import Image
import os

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=os.environ.get("COMETAPI_KEY"),
)

collage = Image.open("collage.jpg")

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=[
        "A model is posing and leaning against a pink BMW with a green alien keychain attached to a pink handbag, a pink parrot on her shoulder, and a pug wearing a pink collar and gold headphones",
        collage,
    ],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
    ),
)

final_image = None
for part in response.parts:
    if getattr(part, "thought", False):
        continue
    if part.inline_data is not None:
        final_image = part.as_image()

if final_image:
    final_image.save("composition_output.png")

curl -s -X POST \
  "https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        { "text": "A model is posing and leaning against a pink BMW with a green alien keychain attached to a pink handbag, a pink parrot on her shoulder, and a pug wearing a pink collar and gold headphones" },
        { "inline_data": { "mime_type": "image/jpeg", "data": "<base64-encoded-collage-image>" } }
      ]
    }],
    "generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
  }'

Methode 2: Mehrere separate Bilder (bis zu 14)

Übergebe mehrere Bilder direkt. Gemini 3-Modelle unterstützen bis zu 14 Referenzbilder (Objekte + Charaktere):

from google import genai
from google.genai import types
from PIL import Image
import os

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=os.environ.get("COMETAPI_KEY"),
)

image1 = Image.open("image1.jpg")
image2 = Image.open("image2.jpg")
image3 = Image.open("image3.jpg")

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents=["Merge the three images", image1, image2, image3],
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
    ),
)

final_image = None
for part in response.parts:
    if getattr(part, "thought", False):
        continue
    if part.inline_data is not None:
        final_image = part.as_image()

if final_image:
    final_image.save("merged_output.png")

curl -s -X POST \
  "https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        { "text": "Merge the three images" },
        { "inline_data": { "mime_type": "image/jpeg", "data": "<base64-image-1>" } },
        { "inline_data": { "mime_type": "image/jpeg", "data": "<base64-image-2>" } },
        { "inline_data": { "mime_type": "image/jpeg", "data": "<base64-image-3>" } }
      ]
    }],
    "generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
  }'

4K-Bildgenerierung

Geben Sie image_config mit aspect_ratio und image_size für eine hochauflösende Ausgabe an:

from google import genai
from google.genai import types
import os

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=os.environ.get("COMETAPI_KEY"),
)

response = client.models.generate_content(
    model="gemini-3.1-flash-image-preview",
    contents="Da Vinci style anatomical sketch of a Monarch butterfly on textured parchment",
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(
            aspect_ratio="1:1",
            image_size="4K",
        ),
    ),
)

final_image = None
for part in response.parts:
    if getattr(part, "thought", False):
        continue
    if part.text is not None:
        print(part.text)
    elif image := part.as_image():
        final_image = image

if final_image:
    final_image.save("butterfly_4k.png")

import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";

const ai = new GoogleGenAI({
  apiKey: process.env.COMETAPI_KEY,
  httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});

const response = await ai.models.generateContent({
  model: "gemini-3.1-flash-image-preview",
  contents: "Da Vinci style anatomical sketch of a Monarch butterfly on textured parchment",
  config: {
    responseModalities: ["TEXT", "IMAGE"],
    imageConfig: { aspectRatio: "1:1", imageSize: "4K" },
  },
});

const imageParts = response.candidates[0].content.parts.filter(
  (part) => part.inlineData && part.thought !== true,
);
const finalImagePart = imageParts.at(-1);

if (finalImagePart) {
  fs.writeFileSync("butterfly_4k.png", Buffer.from(finalImagePart.inlineData.data, "base64"));
}

curl -s -X POST \
  "https://api.cometapi.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Da Vinci style anatomical sketch of a Monarch butterfly on textured parchment"}]}],
    "generationConfig": {
      "responseModalities": ["TEXT", "IMAGE"],
      "imageConfig": {"aspectRatio": "1:1", "imageSize": "4K"}
    }
  }'

Beurteilen Sie bei hochauflösenden Anfragen die Ausgabe anhand des letzten Bildteils ohne thought. Wenn Ihre Integration den ersten inlineData-Teil speichert, speichert sie möglicherweise ein Zwischenbild aus dem thought-Prozess, das eine niedrigere Auflösung als die angeforderte imageSize hat.

Mehrstufige Bildbearbeitung (Chat)

Verwenden Sie die Chat-Funktion des SDK, um Bilder iterativ zu verfeinern:

from google import genai
from google.genai import types
import os

client = genai.Client(
    http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
    api_key=os.environ.get("COMETAPI_KEY"),
)

chat = client.chats.create(
    model="gemini-3.1-flash-image-preview",
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
    ),
)

## First turn: Generate
response = chat.send_message(
    "Create a vibrant infographic explaining photosynthesis as a recipe, styled like a colorful kids cookbook"
)

final_image = None
for part in response.parts:
    if getattr(part, "thought", False):
        continue
    if part.text is not None:
        print(part.text)
    elif image := part.as_image():
        final_image = image

if final_image:
    final_image.save("photosynthesis.png")

Zweiter Durchlauf: Verfeinern

response = chat.send_message(“Aktualisiere diese Infografik so, dass sie auf Spanisch ist. Ändere keine anderen Elemente.”)

final_image = None
for part in response.parts:
if getattr(part, “thought”, False):
continue
if part.text is not None:
print(part.text)
elif image := part.as_image():
final_image = image

if final_image:
final_image.save(“photosynthesis_spanish.png”)

```javascript Node.js
import { GoogleGenAI } from "@google/genai";
import * as fs from "fs";

const ai = new GoogleGenAI({
  apiKey: process.env.COMETAPI_KEY,
  httpOptions: { apiVersion: "v1beta", baseUrl: "https://api.cometapi.com" },
});

const chat = ai.chats.create({
  model: "gemini-3.1-flash-image-preview",
  config: { responseModalities: ["TEXT", "IMAGE"] },
});

// First turn: generate
const response1 = await chat.sendMessage(
  "Create a vibrant infographic explaining photosynthesis as a recipe, styled like a colorful kids cookbook"
);
const imageParts1 = response1.candidates[0].content.parts.filter(
  (part) => part.inlineData && part.thought !== true,
);
const finalImagePart1 = imageParts1.at(-1);
if (finalImagePart1) {
  fs.writeFileSync("photosynthesis.png", Buffer.from(finalImagePart1.inlineData.data, "base64"));
}

// Second turn: refine
const response2 = await chat.sendMessage(
  "Update this infographic to be in Spanish. Do not change any other elements."
);
const imageParts2 = response2.candidates[0].content.parts.filter(
  (part) => part.inlineData && part.thought !== true,
);
const finalImagePart2 = imageParts2.at(-1);
if (finalImagePart2) {
  fs.writeFileSync("photosynthesis_spanish.png", Buffer.from(finalImagePart2.inlineData.data, "base64"));
}

Tipps

Prompt-Optimierung

Gib Stil-Schlüsselwörter an (z. B. „cyberpunk, film grain, low contrast“), Seitenverhältnis, Motiv, Hintergrund, Beleuchtung und Detailgrad.

Base64-Format

Wenn du rohes HTTP verwendest, füge nicht das Präfix data:image/png;base64, hinzu — verwende nur den rohen Base64-String. Das Python SDK übernimmt dies automatisch mit PIL.Image-Objekten.

Bildausgabe erzwingen

Setze "responseModalities" nur auf ["IMAGE"], um eine Bildausgabe ohne Text zu gewährleisten.

Warum ist mein Bild unscharf oder hat eine niedrigere Auflösung?

Prüfe, ob dein Code ein Zwischenbild aus den Gedanken gespeichert hat. Gemini-Bildantworten können Bildteile enthalten, bei denen thought auf true gesetzt ist; diese sind nicht die endgültige Ausgabe. Überspringe Teile mit thought: true und speichere den letzten Bildteil, bei dem inlineData vorhanden ist und thought nicht true ist. Wenn du keine Textausgabe benötigst, fordere "responseModalities": ["IMAGE"] an, um die Verarbeitung gemischter Text-/Bildantworten zu reduzieren.

Weitere Details findest du in der API-Referenz. Offizielle Dokumentation: Nano Banana-Bildgenerierung

Gemini Bildverständnis

Inhaltsmoderation

API-Schlüssel

Einrichtung

Text-to-image-Generierung

Bild-zu-Bild-Generierung

Multi-image-Komposition

Methode 1: Einzelnes Collage-Bild

Methode 2: Mehrere separate Bilder (bis zu 14)

4K-Bildgenerierung

Mehrstufige Bildbearbeitung (Chat)

Tipps

​Einrichtung

​Text-to-image-Generierung

​Bild-zu-Bild-Generierung

​Multi-image-Komposition

​Methode 1: Einzelnes Collage-Bild

​Methode 2: Mehrere separate Bilder (bis zu 14)

​4K-Bildgenerierung

​Mehrstufige Bildbearbeitung (Chat)

​Tipps

Einrichtung

Text-to-image-Generierung

Bild-zu-Bild-Generierung

Multi-image-Komposition

Methode 1: Einzelnes Collage-Bild

Methode 2: Mehrere separate Bilder (bis zu 14)

4K-Bildgenerierung

Mehrstufige Bildbearbeitung (Chat)

Tipps