Bilddateien mit der Gemini API analysieren

Sie können ein Gemini-Modell bitten, Bilddateien zu analysieren, die Sie entweder inline (base64-codiert) oder über eine URL bereitstellen. Wenn Sie Firebase AI Logic verwenden, können Sie diese Anfrage direkt über Ihre App stellen.

Mit dieser Funktion können Sie beispielsweise Folgendes tun:

  • Bildunterschriften erstellen oder Fragen zu Bildern beantworten
  • Kurzgeschichte oder Gedicht über ein Bild schreiben
  • Objekte in einem Bild erkennen und Begrenzungsrahmenkoordinaten für sie zurückgeben
  • Eine Reihe von Bildern nach Stimmung, Stil oder anderen Merkmalen labeln oder kategorisieren

In diesem Leitfaden geht es um das Generieren von Text aus Bildeingaben. Sie können aber auch Bilder aus Bildeingaben generieren.

Zu Codebeispielen springen

Zu Code für gestreamte Antworten springen


Weitere Optionen für die Arbeit mit Bildern finden Sie in anderen Leitfäden
Strukturierte Ausgabe generieren Multi-Turn-Unterhaltung Bilder auf dem Gerät analysieren Bilder generieren

Hinweis

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Falls noch nicht geschehen, lesen Sie den Startleitfaden. Dort wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Backend-Dienst für den ausgewählten Gemini API-Anbieter initialisieren und eine GenerativeModel-Instanz erstellen.

Zum Testen und Iterieren Ihrer Prompts empfehlen wir die Verwendung von Google AI Studio.

Modelle, die diese Funktion unterstützen

In diesem Leitfaden geht es um das Generieren von Text aus Bildeingaben. Er gilt für die folgenden Gemini-Modelle:

  • gemini-4-argon
  • gemini-3.8-flash (und die älteren gemini-3.7-flash, gemini-3.6-flash und gemini-3.5-flash)
  • gemini-3.5-flash-lite (und die ältere gemini-3.1-flash-lite)

Die Modelle gemini-3.1-pro-preview und die allgemeinen Gemini 2.5-Modelle (die verworfen wurden) unterstützen diese Funktion ebenfalls.

Text aus Bilddateien generieren (Base64-codiert)

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Vorbereitung dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API-Anbieter, damit Sie auf dieser Seite anbieterspezifische Inhalte sehen.

Sie können ein Gemini-Modell auffordern, Text zu generieren, indem Sie einen Prompt mit Text und Bildern senden. Geben Sie dazu den mimeType jeder Eingabedatei und die Datei selbst an. Anforderungen und Empfehlungen für Eingabedateien finden Sie weiter unten auf dieser Seite.

Swift

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und Bildern zu generieren.

Eingabe einer einzelnen Datei 


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case.
let model = ai.generativeModel(modelName: "gemini-3.8-flash")


guard let image = UIImage(systemName: "bicycle") else { fatalError() }

// Provide a text prompt to include with the image
let prompt = "What's in this picture?"

// To generate text output, call generateContent and pass in the prompt
let response = try await model.generateContent(image, prompt)
print(response.text ?? "No text in response.")

Eingabe mehrerer Dateien


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case.
let model = ai.generativeModel(modelName: "gemini-3.8-flash")


guard let image1 = UIImage(systemName: "car") else { fatalError() }
guard let image2 = UIImage(systemName: "car.2") else { fatalError() }

// Provide a text prompt to include with the images
let prompt = "What's different between these pictures?"

// To generate text output, call generateContent and pass in the prompt
let response = try await model.generateContent(image1, image2, prompt)
print(response.text ?? "No text in response.")

Kotlin

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und Bildern zu generieren.

In Kotlin sind die Methoden in diesem SDK Suspend-Funktionen und müssen aus einem Koroutinenbereich aufgerufen werden.

Eingabe einer einzelnen Datei 


// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3.8-flash")


// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Eingabe mehrerer Dateien

In Kotlin sind die Methoden in diesem SDK Suspend-Funktionen und müssen aus einem Koroutinenbereich aufgerufen werden. 

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3.8-flash")


// Loads an image from the app/res/drawable/ directory
val bitmap1: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)
val bitmap2: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky_eats_pizza)

// Provide a prompt that includes the images specified above and text
val prompt = content {
  image(bitmap1)
  image(bitmap2)
  text("What is different between these pictures?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Java

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und Bildern zu generieren.

In Java geben die Methoden in diesem SDK ein ListenableFuture zurück.

Eingabe einer einzelnen Datei 


// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Eingabe mehrerer Dateien


// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.8-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);
Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky_eats_pizza);

// Provide a prompt that includes the images specified above and text
Content prompt = new Content.Builder()
    .addImage(bitmap1)
    .addImage(bitmap2)
    .addText("What's different between these pictures?")
    .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und Bildern zu generieren.

Eingabe einer einzelnen Datei 


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case.
const model = getGenerativeModel(ai, { model: "gemini-3.8-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    type: "inlineData",
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the image
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call generateContent with the text and image
  const result = await model.generateContent([prompt, imagePart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Eingabe mehrerer Dateien


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case.
const model = getGenerativeModel(ai, { model: "gemini-3.8-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    type: "inlineData",
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the images
  const prompt = "What's different between these pictures?";

  // Prepare images for input
  const fileInputEl = document.querySelector("input[type=file]");
  const imageParts = await Promise.all(
    [...fileInputEl.files].map(fileToGenerativePart)
  );

  // To generate text output, call generateContent with the text and images
  const result = await model.generateContent([prompt, ...imageParts]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und Bildern zu generieren.

Eingabe einer einzelnen Datei 


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3.8-flash');


// Provide a text prompt to include with the image
final prompt = TextPart("What's in the picture?");
// Prepare images for input
final image = await File('image0.jpg').readAsBytes();
final imagePart = InlineDataPart('image/jpeg', image);

// To generate text output, call generateContent with the text and image
final response = await model.generateContent([
  Content.multi([prompt,imagePart])
]);
print(response.text);

Eingabe mehrerer Dateien


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3.8-flash');


final (firstImage, secondImage) = await (
  File('image0.jpg').readAsBytes(),
  File('image1.jpg').readAsBytes()
).wait;
// Provide a text prompt to include with the images
final prompt = TextPart("What's different between these pictures?");
// Prepare images for input
final imageParts = [
  InlineDataPart('image/jpeg', firstImage),
  InlineDataPart('image/jpeg', secondImage),
];

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, ...imageParts])
]);
print(response.text);

Einheit

Sie können GenerateContentAsync() aufrufen, um Text aus multimodalen Eingaben von Text und Bildern zu generieren.

Eingabe einer einzelnen Datei 


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case.
var model = ai.GetGenerativeModel(modelName: "gemini-3.8-flash");


// Convert a Texture2D into InlineDataParts
var grayImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.grayTexture));

// Provide a text prompt to include with the image
var prompt = ModelContent.Text("What's in this picture?");

// To generate text output, call GenerateContentAsync and pass in the prompt
var response = await model.GenerateContentAsync(new [] { grayImage, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Eingabe mehrerer Dateien


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case.
var model = ai.GetGenerativeModel(modelName: "gemini-3.8-flash");


// Convert Texture2Ds into InlineDataParts
var blackImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.blackTexture));
var whiteImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.whiteTexture));

// Provide a text prompt to include with the images
var prompt = ModelContent.Text("What's different between these pictures?");

// To generate text output, call GenerateContentAsync and pass in the prompt
var response = await model.GenerateContentAsync(new [] { blackImage, whiteImage, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Hier erfahren Sie, wie Sie ein Modell auswählen, die für Ihren Anwendungsfall und Ihre App geeignet sind.

Antwort streamen

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Vorbereitung dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API-Anbieter, damit Sie auf dieser Seite anbieterspezifische Inhalte sehen.

Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das gesamte Ergebnis der Modellgenerierung warten, sondern stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten. Rufen Sie generateContentStream auf, um die Antwort zu streamen.


Anforderungen und Empfehlungen für Eingabebilddateien

Beachten Sie, dass eine als Inline-Daten bereitgestellte Datei bei der Übertragung in Base64 codiert wird, was die Größe der Anfrage erhöht. Sie erhalten einen HTTP 413-Fehler, wenn eine Anfrage zu groß ist.

Auf der Seite „Unterstützte Eingabedateien und Anforderungen“ finden Sie detaillierte Informationen zu folgenden Themen:

Unterstützte MIME-Typen für Bilder

Multimodale Gemini-Modelle unterstützen die folgenden MIME-Bildtypen:

  • PNG - image/png
  • JPEG - image/jpeg
  • WebP – image/webp

Limits pro Anfrage

Es gibt keine bestimmte Beschränkung für die Anzahl der Pixel in einem Bild. Größere Bilder werden jedoch herunterskaliert und auf eine maximale Auflösung von 3072 × 3072 aufgefüllt, wobei ihr ursprüngliches Seitenverhältnis beibehalten wird.

Maximale Anzahl von Dateien pro Anfrage: 3.000 Bilddateien


Was kannst du sonst noch alles für mich tun?

  • Tokens zählen, bevor Sie lange Prompts an das Modell senden.
  • Richten Sie Cloud Storage for Firebase ein, damit Sie große Dateien in Ihre multimodalen Anfragen aufnehmen können und eine besser verwaltete Lösung für die Bereitstellung von Dateien in Prompts haben. Dateien können Bilder, PDFs, Videos und Audioinhalte enthalten.
  • Beginnen Sie mit der Vorbereitung für die Produktion (siehe Produktionscheckliste):

Andere Funktionen ausprobieren

Informationen zum Steuern der Inhaltsgenerierung

Sie können auch mit Prompts und Modellkonfigurationen experimentieren und sogar ein generiertes Code-Snippet mit Google AI Studio abrufen.

Weitere Informationen zu den unterstützten Modellen

Informieren Sie sich über die Modelle, die für verschiedene Anwendungsfälle verfügbar sind, sowie über die zugehörigen Kontingente und Preise.


Feedback zu Ihren Erfahrungen mit Firebase AI Logic geben