Vertex AI in Firebase

Per accedere all'API Gemini e alla famiglia di modelli Gemini direttamente dalla tua app, consigliamo di utilizzare Vertex AI nell'SDK Firebase per Android. Questo SDK fa parte della più ampia piattaforma Firebase che ti aiuta a creare ed eseguire app full-stack.

Eseguire la migrazione dall'SDK client Google AI

L'SDK Vertex AI in Firebase è simile all'SDK client Google AI, ma l'SDK Vertex AI in Firebase offre opzioni di sicurezza fondamentali e altre funzionalità per i casi d'uso di produzione. Ad esempio, quando utilizzi Vertex AI in Firebase puoi anche utilizzare quanto segue:

• Firebase App Check per proteggere l'API Gemini da comportamenti illeciti da parte di client non autorizzati.

• Firebase Remote Config per impostare e modificare dinamicamente i valori per la tua app nel cloud (ad esempio i nomi dei modelli) senza dover rilasciare una nuova versione dell'app.

• Cloud Storage for Firebase per includere file multimediali di grandi dimensioni nella richiesta all'API Gemini.

Se hai già integrato l'SDK client AI di Google nella tua app, puoi eseguire la migrazione a Vertex AI in Firebase.

Per iniziare

Prima di interagire con l'API Gemini direttamente dalla tua app, devi svolgere alcune operazioni preliminari, tra cui acquisire familiarità con i prompt e configurare Firebase e la tua app per utilizzare l'SDK.

Sperimenta con i prompt

Puoi fare esperimenti con i prompt in Vertex AI Studio. Vertex AI Studio è un IDE per la progettazione e la prototipazione dei prompt. Ti consente di caricare file per testare i prompt con testo e immagini e di salvare un prompt per rivisitarlo in un secondo momento.

Creare il prompt giusto per il tuo caso d'uso è più un'arte che una scienza, il che rende la sperimentazione fondamentale. Per scoprire di più sui prompt, consulta la documentazione di Firebase.

Configura un progetto Firebase e collega la tua app a Firebase

Quando è tutto pronto per chiamare l'API Gemini dalla tua app, segui le istruzioni riportate nella guida introduttiva di Vertex AI in Firebase per configurare Firebase e l'SDK nella tua app. La guida introduttiva ti aiuterà a svolgere tutte le attività riportate di seguito in questa guida.

1. Configura un progetto Firebase nuovo o esistente, ad esempio utilizzando il piano tariffario Blaze con pagamento a consumo e attivando le API richieste.

2. Collega la tua app a Firebase, inclusa la registrazione e l'aggiunta del file di configurazione Firebase (google-services.json) all'app.

Aggiungi la dipendenza Gradle

Aggiungi la seguente dipendenza Gradle al modulo dell'app:

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

Inizializza il servizio Vertex AI e il modello generativo

Inizia creando un'istanza di GenerativeModel e specificando il nome del modello:

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

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

Nella documentazione di Firebase puoi scoprire di più sui modelli disponibili da utilizzare con Vertex AI in Firebase. Puoi anche approfondire la configurazione dei parametri del modello.

Interagire con l'API Gemini dalla tua app

Ora che hai configurato Firebase e la tua app per utilizzare l'SDK, puoi interagire con l'API Gemini dalla tua app.

Genera testo

Per generare una risposta di testo, chiama generateContent() con il tuo prompt.

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

Genera testo da immagini e altri contenuti multimediali

Puoi anche generare testo da un prompt che include testo, immagini o altri contenuti multimediali. Quando chiami generateContent(), puoi passare i contenuti multimediali come dati in linea (come mostrato nell'esempio di seguito). In alternativa, puoi includere file multimediali di grandi dimensioni in una richiesta utilizzando gli URL di Cloud Storage for 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);

Chat multi-turno

Puoi anche supportare conversazioni a più turni. Inizializza una chat con la funzione startChat(). Se vuoi, puoi fornire una cronologia dei messaggi. Quindi, chiama la funzione sendMessage() per inviare messaggi di chat.

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

});

Visualizza la risposta in streaming

Puoi ottenere interazioni più rapide non aspettando l'intero risultato della generazione del modello, ma utilizzando lo streaming per gestire i risultati parziali. Utilizza generateContentStream() per trasmettere una risposta in streaming.

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

Passaggi successivi

• Esamina l'app di esempio Vertex AI in Firebase su GitHub.
• Inizia a pensare alla preparazione alla produzione, inclusa la configurazione di Firebase App Check per proteggere l'API Gemini da comportamenti illeciti da parte di client non autorizzati.
• Scopri di più su Vertex AI in Firebase nella documentazione di Firebase.