Vertex AI in Firebase

Wenn Sie direkt über Ihre App auf die Gemini API und die Gemini-Modelle zugreifen möchten, empfehlen wir, das Vertex AI in Firebase SDK für Android zu verwenden. Dieses SDK ist Teil der größeren Firebase-Plattform, mit der Sie Full-Stack-Apps entwickeln und ausführen können.

Architektur der Vertex AI-Integration in Firebase
Abbildung 1: Architektur der Vertex AI in Firebase-Integration.

Vom Google AI Client SDK migrieren

Das Vertex AI SDK in Firebase ähnelt dem Google AI Client SDK, bietet aber wichtige Sicherheitsoptionen und andere Funktionen für Produktionsanwendungen. Wenn Sie beispielsweise Vertex AI in Firebase verwenden, können Sie auch Folgendes verwenden:

  • Firebase App Check zum Schutz der Gemini API vor Missbrauch durch nicht autorisierte Clients.

  • Firebase Remote Config, um Werte für Ihre App in der Cloud dynamisch festzulegen und zu ändern (z. B. Modellnamen), ohne eine neue Version Ihrer App veröffentlichen zu müssen.

  • Cloud Storage for Firebase, um große Mediendateien in Ihre Anfrage an die Gemini API aufzunehmen.

Wenn Sie das Google AI Client SDK bereits in Ihre App eingebunden haben, können Sie zu Vertex AI in Firebase migrieren.

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

Sie können in Vertex AI Studio mit Prompts experimentieren. Vertex AI Studio ist eine IDE für das Entwerfen und Prototyping von Prompts. Sie können Dateien hochladen, um Prompts mit Text und Bildern zu testen, und einen Prompt speichern, um ihn später noch einmal aufzurufen.

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.

Firebase-Projekt einrichten und App mit Firebase verknüpfen

Wenn Sie die Gemini API in Ihrer App aufrufen möchten, folgen Sie der Anleitung im Einstiegsleitfaden für Vertex AI in Firebase, um Firebase und das SDK in Ihrer App einzurichten. Der Einstiegsleitfaden hilft Ihnen bei allen folgenden Aufgaben in diesem Leitfaden.

  1. Richten Sie ein neues oder bestehendes Firebase-Projekt ein. Verwenden Sie dabei den Pay-as-you-go-Preisplan für Blaze und aktivieren Sie die erforderlichen APIs.

  2. Verbinden Sie Ihre App mit Firebase. Dazu müssen Sie Ihre App registrieren und die Firebase-Konfigurationsdatei (google-services.json) hinzufügen.

Gradle-Abhängigkeit hinzufügen

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

Kotlin

dependencies {
  ...
  implementation("com.google.firebase:firebase-vertexai:16.0.2")
}

Java

dependencies {

   [...]

   implementation("com.google.firebase:firebase-vertexai:16.0.2")

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

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

Vertex AI-Dienst und generatives Modell initialisieren

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

Kotlin

val generativeModel = Firebase.vertexAI.generativeModel("gemini-1.5-flash")

Java

GenerativeModel gm = FirebaseVertexAI.getInstance().generativeModel("gemini-1.5-flash");

In der Firebase-Dokumentation finden Sie weitere Informationen zu den verfügbaren Modellen, die Sie mit Vertex AI in Firebase verwenden können. Weitere Informationen zum Konfigurieren von Modellparametern

Über Ihre App mit der Gemini API interagieren

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

Text generieren

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

Kotlin

// Note: `generateContent()` is a `suspend` function, which integrates well
// with existing Kotlin code.

scope.launch {
  val response = model.generateContent("Write a story about the green robot")
}

Java

// In Java, create a `GenerativeModelFutures` from the `GenerativeModel`.
// Note that `generateContent()` returns a `ListenableFuture`. Learn more:
// https://developer.android.com/develop/background-work/background-tasks/asynchronous/listenablefuture

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content prompt = new Content.Builder()
    .addText("Write a story about a green robot.")
    .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 (wie im Beispiel unten gezeigt). Alternativ können Sie große Mediendateien in eine Anfrage einbeziehen, indem Sie Cloud Storage for Firebase-URLs verwenden.

Kotlin

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

Java

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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

Content prompt = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .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);

Unterhaltungen mit mehreren Antworten

Sie können auch Unterhaltungen über mehrere Themen unterstützen. Chat mit der Funktion startChat() initialisieren Optional können Sie einen Nachrichtenverlauf angeben. Rufen Sie dann die Funktion sendMessage() auf, um Chatnachrichten zu senden.

Kotlin

val chat = generativeModel.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

// (Optional) create message history
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();

Publisher<GenerateContentResponse> streamingResponse =
        chat.sendMessageStream(message);

StringBuilder outputContent = new StringBuilder();

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        outputContent.append(chunk);
    }

    @Override
    public void onComplete() {
        // ...
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE);
    }

});

Antwort streamen

Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das vollständige Ergebnis der Modellgenerierung warten, sondern stattdessen Streaming zum Verarbeiten von Teilergebnissen verwenden. Verwenden Sie generateContentStream(), um eine Antwort zu streamen.

Kotlin

scope.launch {
  var outputContent = ""

  generativeModel.generateContentStream(inputContent)
          .collect { response ->
            outputContent += response.text
          }
}

Java

// Note that in Java the method `generateContentStream()` returns a
// Publisher from the Reactive Streams library.
// https://www.reactive-streams.org/

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// Provide a prompt that contains text
Content prompt = new Content.Builder()
        .addText("Write a story about a green robot.")
        .build();

Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(prompt);

StringBuilder outputContent = new StringBuilder();
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onNext(GenerateContentResponse generateContentResponse) {
    String chunk = generateContentResponse.getText();
    outputContent.append(chunk);
  }

  @Override
  public void onComplete() {
    // ...
  }

  @Override
  public void onError(Throwable t) {
    t.printStackTrace();
  }

  @Override
  public void onSubscribe(Subscription s) {
    s.request(Long.MAX_VALUE);
  }
});

Nächste Schritte