Gemini Developer API

Die Gemini Developer API bietet Zugriff auf die Gemini-Modelle von Google. So können Sie in Ihre Android-Apps innovative generative KI-Funktionen einbauen, darunter Konversations-Chat, Bildgenerierung (mit Nano Banana) und Textgenerierung auf der Grundlage von Text-, Bild-, Audio- und Videoeingaben.

Wenn Sie auf die Modelle Gemini Pro und Flash zugreifen möchten, können Sie die Gemini Developer API mit Firebase AI Logic verwenden. So können Sie ohne Kreditkarte loslegen und eine großzügige kostenlose Stufe nutzen. Sobald Sie Ihre Integration mit einer kleinen Nutzerbasis validiert haben, können Sie auf die kostenpflichtige Stufe umsteigen.

Abbildung einer Android-App, die ein Firebase Android SDK enthält. Ein Pfeil zeigt vom SDK zu Firebase in einer Cloud-Umgebung. Von Firebase aus zeigt ein weiterer Pfeil auf die Gemini Developer API, die mit Gemini Pro und Flash verbunden ist, ebenfalls in der Cloud.
Abbildung 1 Integrationsarchitektur von Firebase AI Logic für den Zugriff auf die Gemini Developer API.

Erste Schritte

Bevor Sie direkt über Ihre App mit der Gemini API interagieren, müssen Sie einige Schritte ausführen. Dazu gehört, sich mit Prompts vertraut zu machen und Firebase und Ihre App für die Verwendung des SDK einzurichten.

Prompts ausprobieren

Wenn Sie mit Prompts experimentieren, können Sie die beste Formulierung, den besten Inhalt und das Format für Ihre Android-App finden. Google AI Studio ist eine integrierte Entwicklungsumgebung (IDE), mit der Sie Prompts für die Anwendungsfälle Ihrer App prototypisieren und entwerfen können.

Das Erstellen effektiver Prompts für Ihren Anwendungsfall erfordert umfangreiche Tests, die ein wichtiger Teil des Prozesses sind. Weitere Informationen zu Prompts finden Sie in der Firebase-Dokumentation.

Wenn Sie mit Ihrem Prompt zufrieden sind, klicken Sie auf die Schaltfläche <> , um Code Snippets zu erhalten, die Sie Ihrem Code hinzufügen können.

Firebase-Projekt einrichten und App mit Firebase verbinden

Wenn Sie die API über Ihre App aufrufen möchten, folgen Sie der Anleitung in Schritt 1 des Leitfadens Erste Schritte mit Firebase AI Logic, um Firebase und das SDK in Ihrer App einzurichten.

Gradle-Abhängigkeit hinzufügen

Fügen Sie dem App-Modul die folgende Gradle-Abhängigkeit hinzu:

Kotlin

dependencies {
  // ... other androidx dependencies

  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:firebase-bom:34.11.0"))

  // Add the dependency for the Firebase AI Logic library When using the BoM,
  // you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
}

Java

dependencies {
  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:34.11.0"))

  // Add the dependency for the Firebase AI Logic library When using the BoM,
  // you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")

  // Required for one-shot operations (to use `ListenableFuture` from Guava
  // Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive
  // Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

Generatives Modell initialisieren

Instanziieren Sie zuerst ein GenerativeModel und geben Sie den Modellnamen an:

Kotlin

// Start by instantiating a GenerativeModel and specifying the model name:
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel("gemini-2.5-flash")
GeminiDeveloperApiSnippets.kt

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);
GeminiDeveloperApiSnippetsJava.java

Weitere Informationen zu den verfügbaren Modellen für die Verwendung mit der Gemini Developer API. Weitere Informationen zum Konfigurieren von Modell parametern.

Über Ihre App mit der Gemini Developer API interagieren

Nachdem Sie Firebase und Ihre App für die Verwendung des SDK eingerichtet haben, können Sie über Ihre App mit der Gemini Developer API interagieren.

Text generieren

Wenn Sie eine Textantwort generieren möchten, rufen Sie generateContent() mit Ihrem Prompt auf.

Kotlin

scope.launch {
    val response = model.generateContent("Write a story about a magic backpack.")
}
GeminiDeveloperApiSnippets.kt

Java

Content prompt = new Content.Builder()
        .addText("Write a story about a magic backpack.")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
    }

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

Text aus Bildern und anderen Medien generieren

Sie können auch Text aus einem Prompt generieren, der Text sowie Bilder oder andere Medien enthält. Wenn Sie generateContent() aufrufen, können Sie die Medien als Inline-Daten übergeben.

Wenn Sie beispielsweise eine Bitmap verwenden möchten, verwenden Sie den Inhaltstyp image:

Kotlin

scope.launch {
    val response = model.generateContent(
        content {
            image(bitmap)
            text("what is the object in the picture?")
        }
    )
}
GeminiDeveloperApiSnippets.kt

Java

Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("what is the object in the picture?")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
    }

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

Wenn Sie eine Audiodatei übergeben möchten, verwenden Sie den Inhaltstyp inlineData:

Kotlin

scope.launch {
    val contentResolver = applicationContext.contentResolver
    contentResolver.openInputStream(audioUri).use { stream ->
        stream?.let {
            val bytes = it.readBytes()

            val prompt = content {
                inlineData(bytes, "audio/mpeg") // Specify the appropriate audio MIME type
                text("Transcribe this audio recording.")
            }

            val response = model.generateContent(prompt)
        }
    }
}
GeminiDeveloperApiSnippets.kt

Java

ContentResolver resolver = applicationContext.getContentResolver();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte[] audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes audio specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
                .addText("Transcribe what's said in this audio recording.")
                .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 text = result.getText();
                Log.d(TAG, (text == null) ? "" : text);
            }
            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
        }, executor);
    } else {
        Log.e(TAG, "Error getting input stream for file.");
        // Handle the error appropriately
    }
} catch (IOException e) {
    Log.e(TAG, "Failed to read the audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}
GeminiDeveloperApiSnippetsJava.java

Wenn Sie eine Videodatei bereitstellen möchten, verwenden Sie weiterhin den Inhaltstyp inlineData:

Kotlin

scope.launch {
    val contentResolver = applicationContext.contentResolver
    contentResolver.openInputStream(videoUri).use { stream ->
        stream?.let {
            val bytes = it.readBytes()

            val prompt = content {
                inlineData(bytes, "video/mp4") // Specify the appropriate video MIME type
                text("Describe the content of this video")
            }

            val response = model.generateContent(prompt)
        }
    }
}
GeminiDeveloperApiSnippets.kt

Java

ContentResolver resolver = applicationContext.getContentResolver();

try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes video specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("Describe the content of this video")
                .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);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}
GeminiDeveloperApiSnippetsJava.java

Ebenso können Sie auch PDF- (application/pdf) und Nur-Text-Dokumente (text/plain) übergeben, indem Sie den entsprechenden MIME-Typ als Parameter übergeben.

Wechselseitiger Chat

Sie können auch Unterhaltungen in mehreren Runden unterstützen. Initialisieren Sie einen Chat mit der Funktion startChat(). Optional können Sie dem Modell einen Nachrichtenverlauf zur Verfügung stellen. Rufen Sie dann die Funktion sendMessage() auf, um Chatnachrichten zu senden.

Kotlin

val chat = model.startChat(
    history = listOf(
        content(role = "user") { text("Hello, I have 2 dogs in my house.") },
        content(role = "model") { text("Great to meet you. What would you like to know?") }
    )
)

scope.launch {
    val response = chat.sendMessage("How many paws are in my house?")
}
GeminiDeveloperApiSnippets.kt

Java

Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = modelContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder messageBuilder = new Content.Builder();
messageBuilder.setRole("user");
messageBuilder.addText("How many paws are in my house?");

Content message = messageBuilder.build();

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
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);
GeminiDeveloperApiSnippetsJava.java

Mit Nano Banana Bilder auf Android-Geräten generieren

Das Modell Gemini 2.5 Flash Image (auch bekannt als Nano Banana) kann Bilder generieren und bearbeiten, indem es auf Weltwissen und logisches Denken zurückgreift. Es generiert kontextbezogene Bilder und kombiniert oder verschachtelt Text- und Bildausgaben nahtlos. Außerdem kann es genaue Bilder mit langen Textsequenzen generieren und die Bearbeitung von Bildern per Prompt unterstützen, während der Kontext beibehalten wird.

Als Alternative zu Gemini können Sie Imagen-Modelle verwenden, insbesondere für die Bildgenerierung in hoher Qualität, die Fotorealismus, künstlerische Details oder bestimmte Stile erfordert. Für die meisten clientseitigen Anwendungsfälle für Android-Apps ist Gemini jedoch mehr als ausreichend.

In diesem Leitfaden wird beschrieben, wie Sie das Modell Gemini 2.5 Flash Image (Nano Banana) mit dem Firebase AI Logic SDK für Android verwenden. Weitere Informationen zum Generieren von Bildern mit Gemini finden Sie in der Dokumentation Bilder mit Gemini in Firebase generieren. Wenn Sie Imagen Modelle verwenden möchten, finden Sie weitere Informationen in der Dokumentation.

Die Google AI Studio-Benutzeroberfläche mit einem Texteingabefeld mit dem Prompt „Ein hyperrealistisches Bild eines T-Rex mit einem blauen Rucksack, der durch einen prähistorischen Wald streift“ und einem generierten Bild eines T-Rex in einem Wald mit einem blauen Rucksack.
Abbildung 2. Mit Google AI Studio Prompts für die Bildgenerierung mit Nano Banana für Android
optimieren

Generatives Modell initialisieren

Instanziieren Sie ein GenerativeModel und geben Sie den Modellnamen gemini-2.5-flash-image-preview an. Achten Sie darauf, dass Sie responseModalities so konfigurieren, dass sowohl TEXT als auch IMAGE enthalten sind.

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "gemini-2.5-flash-image-preview",
    // Configure the model to respond with text and images (required)
    generationConfig = generationConfig {
        responseModalities = listOf(
            ResponseModality.TEXT,
            ResponseModality.IMAGE
        )
    }
)
GeminiDeveloperApiSnippets.kt

Java

GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
        "gemini-2.5-flash-image-preview",
        // Configure the model to respond with text and images (required)
        new GenerationConfig.Builder()
                .setResponseModalities(Arrays.asList(ResponseModality.TEXT, ResponseModality.IMAGE))
                .build()
);
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
GeminiDeveloperApiSnippetsJava.java

Bilder generieren (nur Texteingabe)

Sie können ein Gemini-Modell anweisen, Bilder zu generieren, indem Sie einen Prompt nur mit Text eingeben:

Kotlin

scope.launch {
    // Provide a text prompt instructing the model to generate an image
    val prompt =
        "A hyper realistic picture of a t-rex with a blue bag pack roaming a pre-historic forest."
    // To generate image output, call `generateContent` with the text input
    val generatedImageAsBitmap: Bitmap? = model.generateContent(prompt)
        .candidates.first().content.parts.filterIsInstance<ImagePart>()
        .firstOrNull()?.image
}
GeminiDeveloperApiSnippets.kt

Java

// Provide a text prompt instructing the model to generate an image
Content prompt = new Content.Builder()
        .addText("Generate an image of the Eiffel Tower with fireworks in the background.")
        .build();
// To generate an image, call `generateContent` with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                // The returned image as a bitmap
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Bilder bearbeiten (Text- und Bildeingabe)

Sie können ein Gemini-Modell bitten, vorhandene Bilder zu bearbeiten, indem Sie in Ihrem Prompt sowohl Text als auch ein oder mehrere Bilder angeben:

Kotlin

scope.launch {
    // Provide a text prompt instructing the model to edit the image
    val prompt = content {
        image(bitmap)
        text("Edit this image to make it look like a cartoon")
    }
    // To edit the image, call `generateContent` with the prompt (image and text input)
    val generatedImageAsBitmap: Bitmap? = model.generateContent(prompt)
        .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
    // Handle the generated text and image
}
GeminiDeveloperApiSnippets.kt

Java

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
// Provide a text prompt instructing the model to edit the image
Content promptcontent = new Content.Builder()
        .addImage(bitmap)
        .addText("Edit this image to make it look like a cartoon")
        .build();
// To edit the image, call `generateContent` with the prompt (image and text input)
ListenableFuture<GenerateContentResponse> response = model.generateContent(promptcontent);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Bilder über einen wechselseitigen Chat iterieren und bearbeiten

Für einen dialogorientierten Ansatz zur Bildbearbeitung können Sie einen wechselseitigen Chat verwenden. So können Sie Folgeanfragen senden, um Änderungen zu verfeinern, ohne das Originalbild noch einmal senden zu müssen.

Initialisieren Sie zuerst einen Chat mit startChat(). Optional können Sie einen Nachrichtenverlauf angeben. Verwenden Sie dann sendMessage() für nachfolgende Nachrichten:

Kotlin

scope.launch {
    // Create the initial prompt instructing the model to edit the image
    val prompt = content {
        image(bitmap)
        text("Edit this image to make it look like a cartoon")
    }
    // Initialize the chat
    val chat = model.startChat()
    // To generate an initial response, send a user message with the image and text prompt
    var response = chat.sendMessage(prompt)
    // Inspect the returned image
    var generatedImageAsBitmap: Bitmap? = response
        .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
    // Follow up requests do not need to specify the image again
    response = chat.sendMessage("But make it old-school line drawing style")
    generatedImageAsBitmap = response
        .candidates.first().content.parts.filterIsInstance<ImagePart>().firstOrNull()?.image
}
GeminiDeveloperApiSnippets.kt

Java

// Provide an image for the model to edit
Bitmap bitmap = BitmapFactory.decodeResource(resources, R.drawable.scones);
// Initialize the chat
ChatFutures chat = model.startChat();
// Create the initial prompt instructing the model to edit the image
Content prompt = new Content.Builder()
        .setRole("user")
        .addImage(bitmap)
        .addText("Edit this image to make it look like a cartoon")
        .build();
// To generate an initial response, send a user message with the image and text prompt
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(prompt);
// Extract the image from the initial response
ListenableFuture<Bitmap> initialRequest = Futures.transform(response,
        result -> {
            for (Part part : result.getCandidates().get(0).getContent().getParts()) {
                if (part instanceof ImagePart) {
                    ImagePart imagePart = (ImagePart) part;
                    return imagePart.getImage();
                }
            }
            return null;
        }, executor);
// Follow up requests do not need to specify the image again
ListenableFuture<GenerateContentResponse> modelResponseFuture = Futures.transformAsync(
        initialRequest,
        generatedImage -> {
            Content followUpPrompt = new Content.Builder()
                    .addText("But make it old-school line drawing style")
                    .build();
            return chat.sendMessage(followUpPrompt);
        }, executor);
// Add a final callback to check the reworked image
Futures.addCallback(modelResponseFuture, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }
    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);
GeminiDeveloperApiSnippetsJava.java

Überlegungen und Einschränkungen

Beachten Sie die folgenden Überlegungen und Einschränkungen:

  • Ausgabeformat: Bilder werden als PNGs mit einer maximalen Größe von 1024 Pixeln generiert.
  • Eingabetypen: Das Modell unterstützt keine Audio- oder Videoeingaben für die Bild generierung.
  • Sprachunterstützung: Die beste Leistung wird mit den folgenden Sprachen erzielt: Englisch (en), Mexikanisches Spanisch (es-mx), Japanisch (ja-jp), Vereinfachtes Chinesisch (zh-cn) und Hindi (hi-in).
  • Probleme bei der Generierung:
    • Die Bildgenerierung wird möglicherweise nicht immer ausgelöst, was manchmal zu einer reinen Textausgabe führt. Bitten Sie explizit um Bildausgaben (z. B. „Generiere ein Bild“, „Stelle Bilder zur Verfügung“, „Aktualisiere das Bild“).
    • Das Modell beendet die Generierung möglicherweise mittendrin. Versuchen Sie es noch einmal oder verwenden Sie einen anderen Prompt.
    • Das Modell generiert möglicherweise Text als Bild. Bitten Sie explizit um Textausgaben (z. B. „Generiere einen erzählenden Text zusammen mit Illustrationen“).

Weitere Informationen finden Sie in der Firebase-Dokumentation.

Nächste Schritte

Nachdem Sie Ihre App eingerichtet haben, sollten Sie die folgenden nächsten Schritte in Betracht ziehen: