Gemini Developer API

Für den Zugriff auf die Modelle Gemini Pro und Flash empfehlen wir Android-Entwicklern, die Gemini Developer API mit Firebase AI Logic zu verwenden. Sie können ohne Kreditkarte loslegen und erhalten eine großzügige kostenlose Stufe. Nachdem Sie Ihre Integration mit einer kleinen Nutzerbasis getestet haben, können Sie sie skalieren, indem Sie auf die kostenpflichtige Stufe umstellen.

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: Architektur der Firebase AI Logic-Integration für den Zugriff auf die Gemini Developer API.

Erste Schritte

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

Prompts ausprobieren

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

Den richtigen Prompt für Ihren Anwendungsfall zu erstellen, ist eher eine Kunst als eine Wissenschaft. Daher ist es wichtig, verschiedene Prompts auszuprobieren. Weitere Informationen zu Aufforderungen 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 bereit sind, die API aus Ihrer App aufzurufen, folgen Sie der Anleitung in Schritt 1 des Firebase AI Logic-Startleitfadens, um Firebase und das SDK in Ihrer App einzurichten.

Gradle-Abhängigkeit hinzufügen

Fügen Sie Ihrem 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.1.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.1.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

val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")

Java

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

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);

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

Mit der Gemini Developer API über Ihre App 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

Rufen Sie generateContent() mit Ihrem Prompt auf, um eine Textantwort zu generieren.

Kotlin

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

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);

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 Media 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?")
    }
  )
}

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);

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

Kotlin

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

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

        val response = model.generateContent(prompt)
    }
}

Java

ContentResolver resolver = getApplicationContext().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);
}

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

Kotlin

val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.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)
  }
}

Java

ContentResolver resolver = getApplicationContext().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();
}

Sie können 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 über mehrere Themen 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?")
}

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 = userContentBuilder.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);

Weitere Informationen finden Sie in der Firebase-Dokumentation.

Nächste Schritte