Gemini Developer API

Für den Zugriff auf die Gemini Pro- und Flash-Modelle empfehlen wir Android-Entwicklern, die Gemini Developer API mit Firebase AI Logic zu verwenden. Sie können ohne Kreditkarte loslegen und es gibt eine großzügige kostenlose Stufe. Sobald Sie Ihre Integration mit einer kleinen Nutzerbasis validiert haben, können Sie skalieren, indem Sie zur kostenpflichtigen Stufe wechseln.

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 ebenfalls in der Cloud mit Gemini Pro und Flash verbunden ist.
Abbildung 1 Firebase AI Logic-Integrationsarchitektur 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 tun. Dazu gehört, sich mit Prompts vertraut zu machen und Firebase und Ihre App so einzurichten, dass das SDK verwendet wird.

Mit Prompts experimentieren

Wenn Sie mit Prompts experimentieren, können Sie die beste Formulierung, die besten Inhalte und das beste Format für Ihre Android-App finden. Google AI Studio ist eine IDE, mit der Sie Prototypen erstellen und Prompts für die Anwendungsfälle Ihrer App entwerfen können.

Der richtige Prompt für Ihren Anwendungsfall ist mehr Kunst als Wissenschaft, weshalb Tests entscheidend sind. Weitere Informationen zu Prompts finden Sie in der Firebase-Dokumentation.

Wenn Sie mit dem 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 aus Ihrer App aufrufen möchten, folgen Sie der Anleitung unter „Schritt 1“ im Startleitfaden für Firebase AI Logic, 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:33.13.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:firebase-bom:33.13.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

Erstellen Sie zuerst eine Instanz von GenerativeModel und geben Sie den Modellnamen an:

Kotlin

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

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.0-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

Über Ihre App mit der Gemini Developer API interagieren

Nachdem Sie Firebase und Ihre App so eingerichtet haben, dass das SDK verwendet wird, 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.")
}

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 du generateContent() aufrufst, kannst du 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?")
    }
  )
}

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

Verwende den Inhaltstyp inlineData, um eine Audiodatei zu übergeben:

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

Verwenden Sie weiterhin den Inhaltstyp inlineData, um eine Videodatei bereitzustellen:

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

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

Unterhaltungen mit mehreren Antworten

Sie können auch Unterhaltungen über mehrere Themen unterstützen. Chat mit der Funktion startChat() initialisieren 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