> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Gemini-Bildmodelle verwenden
> Rufen Sie Gemini-Bildmodelle (Nano Banana 2 / Pro) auf CometAPI mit dem Google Gen AI SDK für Text-zu-Bild, Bild-zu-Bild und die Komposition mehrerer Bilder auf.
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:
```python Python theme={null}
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,
)
```
```javascript Node.js theme={null}
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" },
});
```
```go Go theme={null}
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.
```python Python theme={null}
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")
```
```javascript Node.js theme={null}
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");
}
```
```bash Shell theme={null}
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:
```json theme={null}
{
"candidates": [{
"content": {
"parts": [
{ "text": "Here is your image..." },
{
"inlineData": {
"mimeType": "image/png",
"data": ""
}
}
]
}
}]
}
```
Antwort mit einem Textteil, einem Zwischenbild für Thought und dem endgültigen Bild:
```json theme={null}
{
"candidates": [{
"content": {
"role": "model",
"parts": [
{ "text": "Here is your image..." },
{
"inlineData": {
"mimeType": "image/jpeg",
"data": ""
},
"thought": true
},
{
"inlineData": {
"mimeType": "image/jpeg",
"data": ""
},
"thought": false,
"thoughtSignature": ""
}
]
},
"finishReason": "STOP"
}]
}
```
Verwenden Sie diese Parsing-Regel für jede Gemini-Bildantwort:
```javascript theme={null}
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.
```python Python theme={null}
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")
```
```javascript Node.js theme={null}
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"));
}
```
```bash Shell theme={null}
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": "" } }
]
}],
"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.
```python Python theme={null}
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")
```
```bash Shell theme={null}
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": "" } }
]
}],
"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):
```python Python theme={null}
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")
```
```bash Shell theme={null}
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": "" } },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } },
{ "inline_data": { "mime_type": "image/jpeg", "data": "" } }
]
}],
"generationConfig": { "responseModalities": ["TEXT", "IMAGE"] }
}'
```
***
## 4K-Bildgenerierung
Geben Sie `image_config` mit `aspect_ratio` und `image_size` für eine hochauflösende Ausgabe an:
```python Python theme={null}
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")
```
```javascript Node.js theme={null}
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"));
}
```
```bash Shell theme={null}
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:
```python Python theme={null}
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
Gib Stil-Schlüsselwörter an (z. B. „cyberpunk, film grain, low contrast“), Seitenverhältnis, Motiv, Hintergrund, Beleuchtung und Detailgrad.
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.
Setze `"responseModalities"` nur auf `["IMAGE"]`, um eine Bildausgabe ohne Text zu gewährleisten.
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](/api/image/gemini/gemini-generates-image).
**Offizielle Dokumentation:** [Nano Banana-Bildgenerierung](https://ai.google.dev/gemini-api/docs/image-generation)
* [Gemini Bildverständnis](https://ai.google.dev/gemini-api/docs/image-understanding)