Vertex AI en Firebase

Para acceder a la API de Gemini y a la familia de modelos de Gemini directamente desde tu app, recomendamos usar el SDK de Vertex AI en Firebase para Android. Este SDK forma parte de la plataforma de Firebase más grande que te ayuda a compilar y ejecutar apps de pila completa.

Arquitectura de integración de Vertex AI en Firebase
Figura 1: Vertex AI en la arquitectura de integración de Firebase.

Migra desde el SDK cliente de Google AI

El SDK de Vertex AI en Firebase es similar al SDK de cliente de Google AI, pero el SDK de Vertex AI en Firebase ofrece opciones de seguridad fundamentales y otras funciones para casos de uso de producción. Por ejemplo, cuando usas Vertex AI en Firebase, también puedes usar lo siguiente:

Si ya integraste el SDK cliente de Google AI en tu app, puedes migrar a Vertex AI en Firebase.

Cómo comenzar

Antes de interactuar con la API de Gemini directamente desde tu app, deberás hacer algunas tareas, como familiarizarte con las indicaciones y configurar Firebase y tu app para usar el SDK.

Experimenta con instrucciones

Puedes experimentar con instrucciones en Vertex AI Studio. Vertex AI Studio es un IDE para el diseño y el prototipado de instrucciones. Te permite subir archivos para probar instrucciones con texto e imágenes, y guardar una instrucción para volver a verla más adelante.

Crear la propuesta correcta para tu caso de uso es más arte que ciencia, lo que hace que la experimentación sea fundamental. Puedes obtener más información sobre las indicaciones en la documentación de Firebase.

Configura un proyecto de Firebase y conecta tu app a Firebase

Cuando tengas todo listo para llamar a la API de Gemini desde tu app, sigue las instrucciones de la guía de introducción a Vertex AI en Firebase para configurar Firebase y el SDK en tu app. La guía de introducción te ayudará a realizar todas las siguientes tareas en esta guía.

  1. Configura un proyecto de Firebase nuevo o existente, incluido el uso del plan de precios Blaze de pago por uso y la habilitación de las APIs necesarias.

  2. Conecta tu app a Firebase, lo que incluye registrarla y agregar el archivo de configuración de Firebase (google-services.json) a la app.

Agrega la dependencia de Gradle

Agrega la siguiente dependencia de Gradle al módulo de tu app:

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

Inicializa el servicio de Vertex AI y el modelo generativo

Para comenzar, crea una instancia de GenerativeModel y especifica el nombre del modelo:

Kotlin

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

Java

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

En la documentación de Firebase, puedes obtener más información sobre los modelos disponibles para usar con Vertex AI en Firebase. También puedes obtener información para configurar parámetros de modelos.

Interactúa con la API de Gemini desde tu app

Ahora que configuraste Firebase y tu app para usar el SDK, ya puedes interactuar con la API de Gemini desde tu app.

Generar texto

Para generar una respuesta de texto, llama a generateContent() con tu instrucción.

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

Genera texto a partir de imágenes y otro contenido multimedia

También puedes generar texto a partir de una instrucción que incluya texto, imágenes o algún otro elemento multimedia. Cuando llames a generateContent(), puedes pasar el contenido multimedia como datos intercalados (como se muestra en el siguiente ejemplo). Como alternativa, puedes incluir archivos multimedia grandes en una solicitud con las URLs de Cloud Storage para 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);

Chat de varios turnos

También puedes admitir conversaciones de varios turnos. Inicializa un chat con la función startChat(). De forma opcional, puedes proporcionar un historial de mensajes. Luego, llama a la función sendMessage() para enviar mensajes de chat.

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

});

Transmite la respuesta

Puedes lograr interacciones más rápidas si no esperas a que se genere todo el resultado del modelo y, en su lugar, usas la transmisión para controlar los resultados parciales. Usa generateContentStream() para transmitir una respuesta.

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

Próximos pasos