API para desarrolladores de Gemini

Para acceder a los modelos Gemini Pro y Flash, recomendamos a los desarrolladores de Android que usen la API de Gemini Developer con la lógica de IA de Firebase. Te permite comenzar sin necesidad de una tarjeta de crédito y ofrece un nivel gratuito generoso. Una vez que validates tu integración con una base de usuarios pequeña, puedes escalar cambiando al nivel pagado.

Ilustración de una app para Android que contiene un SDK de Firebase para Android. Una flecha apunta del SDK a Firebase dentro de un entorno de Cloud. Desde Firebase, otra flecha apunta a la API de Gemini para desarrolladores, que está conectada a Gemini Pro y Flash, también dentro de Cloud.
Figura 1: Arquitectura de integración de la lógica de IA de Firebase para acceder a la API para desarrolladores de Gemini

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

Experimentar con instrucciones puede ayudarte a encontrar la mejor fraseología, el mejor contenido y el mejor formato para tu app para Android. Google AI Studio es un IDE que puedes usar para crear prototipos y diseñar instrucciones para los casos de uso de tu app.

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.

Una vez que estés conforme con la instrucción, haz clic en el botón “<>" para obtener fragmentos de código que puedes agregar a tu código.

Configura un proyecto de Firebase y conecta tu app a Firebase

Cuando tengas todo listo para llamar a la API desde tu app, sigue las instrucciones que se indican en el "Paso 1" de la Guía de introducción a la lógica de IA de Firebase para configurar Firebase y el SDK en tu app.

Agrega la dependencia de Gradle

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

Kotlin

dependencies {
  // ... other androidx dependencies

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

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

Java

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

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

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

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

Inicializa el modelo generativo

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

Kotlin

val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.0-flash")

Java

GenerativeModel firebaseAI = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.0-flash");

GenerativeModelFutures model = GenerativeModelFutures.from(firebaseAI);

Obtén más información sobre los modelos disponibles para usar con la API para desarrolladores de Gemini. También puedes obtener más información para configurar los parámetros del modelo.

Interactúa con la API de Gemini Developer desde tu app

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

Generar texto

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

Kotlin

scope.launch {
  val response = model.generateContent("Write a story about a magic backpack.")
}

Java

Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .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.

Por ejemplo, para usar un mapa de bits, usa el tipo de contenido image:

Kotlin

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

Java

Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("what is the object in the picture?")
        .build();

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
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);

Para pasar un archivo de audio, usa el tipo de contenido inlineData:

Kotlin

val contentResolver = applicationContext.contentResolver
val inputStream = contentResolver.openInputStream(audioUri).use { stream ->
    stream?.let {
        val bytes = stream.readBytes()

        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe this audio recording.")
        }

        val response = model.generateContent(prompt)
    }
}

Java

ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes audio specified earlier and text
        Content prompt = new Content.Builder()
              .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
              .addText("Transcribe what's said in this audio recording.")
              .build();

        // To generate text output, call `generateContent` with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String text = result.getText();
                Log.d(TAG, (text == null) ? "" : text);
            }
            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
        }, executor);
    } else {
        Log.e(TAG, "Error getting input stream for file.");
        // Handle the error appropriately
    }
} catch (IOException e) {
    Log.e(TAG, "Failed to read the audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}

Para proporcionar un archivo de video, sigue usando el tipo de contenido inlineData:

Kotlin

val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    val prompt = content {
        inlineData(bytes, "video/mp4")  // Specify the appropriate video MIME type
        text("Describe the content of this video")
    }

    val response = model.generateContent(prompt)
  }
}

Java

ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes video specified earlier and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("Describe the content of this video")
                .build();

        // To generate text output, call generateContent with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Del mismo modo, también puedes pasar documentos PDF (application/pdf) y de texto sin formato (text/plain) pasando su respectivo tipo MIME como parámetro.

Chat de varios turnos

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

Kotlin

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

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

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(message);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Consulta la documentación de Firebase para obtener más detalles.

Próximos pasos