Vertex AI w Firebase

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

Migracja z pakietu SDK klienta Google AI

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

• Sprawdzanie aplikacji Firebase, aby chronić interfejs Gemini API przed nadużyciami przez nieautoryzowanych klientów.

• Zdalnej konfiguracji Firebase, aby dynamicznie ustawiać i zmieniać wartości w aplikacji w chmurze (np. nazwy modeli) bez konieczności wydawania nowej wersji aplikacji.

• Cloud Storage dla Firebase, aby uwzględnić duże pliki multimedialne w żądaniu wysyłanym do interfejsu Gemini API.

Jeśli masz już zintegrowany pakiet SDK klienta Google AI w swojej aplikacji, 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.

Stworzenie odpowiedniego promptu do danego zastosowania to bardziej sztuka niż nauka, 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 Gemini API z aplikacji, postępuj zgodnie z instrukcjami w przewodniku Vertex AI w Firebase, aby skonfigurować Firebase i pakiet SDK w swojej aplikacji. Ten przewodnik 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:

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

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

Inicjowanie usługi Vertex AI i modela generatywnego

Zacznij od utworzenia instancji GenerativeModel i podania nazwy modelu:

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

GenerativeModel gm = FirebaseVertexAI.getInstance().generativeModel("gemini-1.5-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 funkcję generateContent() z promptem.

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

// 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.

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

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.

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

// (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

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

scope.launch {
  var outputContent = ""

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

// 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

• Zapoznaj się z przykładową aplikacją Vertex AI w Firebase na GitHubie.
• Zacznij myśleć o przygotowaniu się do wdrożenia, w tym o skonfigurowaniu Sprawdzania aplikacji Firebase, aby chronić interfejs Gemini API przed nadużyciami przez nieupoważnionych klientów.
• Więcej informacji o Vertex AI w Firebase znajdziesz w dokumentacji Firebase.