Vertex AI w Firebase

Aby uzyskać dostęp do interfejsu Gemini API i modeli z rodziny Gemini bezpośrednio z aplikacji, zalecamy użycie pakietu Vertex AI w Firebase SDK na Androida. Ten pakiet SDK jest częścią większej platformy Firebase, która pomaga tworzyć i uruchamiać kompleksowe aplikacje.

Architektura integracji Vertex AI w Firebase
Rysunek 1. architektura integracji Vertex AI w Firebase.

Migracja z pakietu SDK klienta Google AI

Pakiet Vertex AI w Firebase SDK jest podobny do pakietu SDK klienta Google AI, ale oferuje ważne opcje zabezpieczeń i inne funkcje do zastosowań produkcyjnych. Korzystając z Vertex AI w Firebase, możesz też korzystać z tych funkcji:

Jeśli pakiet SDK klienta Google AI jest już zintegrowany z Twoją aplikacją, możesz przenieść ją na Vertex AI w Firebase.

Pierwsze kroki

Zanim zaczniesz korzystać z interfejsu Gemini API bezpośrednio z aplikacji, musisz wykonać kilka czynności, m.in. zapoznać się z wyświetlaniem promptów i skonfigurować Firebase oraz aplikację, aby używać pakietu SDK.

Eksperymentowanie z promptami

Prompty możesz testować w Vertex AI Studio. Vertex AI Studio to środowisko IDE do projektowania promptów i tworzenia prototypów. Umożliwia przesyłanie plików z tekstem i obrazami do testowania promptów oraz zapisywanie promptów, aby wrócić do nich później.

Tworzenie odpowiedniego promptu do danego zastosowania jest bardziej sztuką niż nauką, dlatego eksperymentowanie jest kluczowe. Więcej informacji o promptach znajdziesz w dokumentacji Firebase.

Konfigurowanie projektu Firebase i łączenie z nim aplikacji

Gdy będziesz gotowy do wywołania interfejsu API Gemini z aplikacji, postępuj zgodnie z instrukcjami w wprowadzeniu do korzystania z Vertex AI w Firebase, aby skonfigurować Firebase i pakiet SDK w swojej aplikacji. Wprowadzenie pomoże Ci wykonać wszystkie czynności opisane w tym przewodniku.

  1. Skonfiguruj nowy lub istniejący projekt Firebase, w tym abonament Blaze z opłatami według wykorzystania, i włącz wymagane interfejsy API.
  2. Połącz aplikację z Firebase, w tym zarejestruj ją i dodaj do niej plik konfiguracji Firebase (google-services.json).

Dodawanie zależności Gradle

Dodaj do modułu aplikacji tę zależność Gradle:

Kotlin

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

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

Java

dependencies {

   [...]

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

   // 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")
}

Inicjowanie usługi Vertex AI i modela generatywnego

Zacznij od utworzenia instancji GenerativeModel i podania nazwy modelu:

Kotlin

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

Java

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

W dokumentacji Firebase możesz dowiedzieć się więcej o dostępnych modelach do użycia z Vertex AI w Firebase. Możesz też dowiedzieć się więcej o konfigurowaniu parametrów modelu.

Interakcja z interfejsem Gemini API z poziomu aplikacji

Po skonfigurowaniu Firebase i swojej aplikacji do korzystania z pakietu SDK możesz już z niego korzystać w swojej aplikacji.

Generowanie tekstu

Aby wygenerować odpowiedź tekstową, wywołaj generateContent() z promptem.

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

generować tekst na podstawie obrazów i innych multimediów;

Możesz też wygenerować tekst na podstawie prompta zawierającego tekst oraz obrazy lub inne multimedia. Gdy wywołujesz funkcję generateContent(), możesz przekazywać dane multimedialne jako dane wbudowane (jak w przykładzie poniżej). Możesz też uwzględnić duże pliki multimedialne w żądaniu, używając Cloud Storage dla adresów URL Firebase.

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

Czat wieloetapowy

Możesz też obsługiwać rozmowy wieloetapowe. Inicjowanie czatu za pomocą funkcji startChat(). Opcjonalnie możesz podać historię wiadomości. Następnie wywołaj funkcję sendMessage(), aby wysłać wiadomości na czacie.

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

});

Odpowiadaj na pytania stopniowo

Możesz uzyskać szybsze interakcje, nie czekając na pełny wynik wygenerowany przez model, a zamiast tego używać strumieniowego przesyłania wyników częściowych. Użyj generateContentStream(), aby przesyłać strumieniowo odpowiedź.

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

Dalsze kroki