SDK cliente de Google AI

Importante: El SDK cliente de Google AI para Android debe usarse solo para prototipar. Si incorporas una clave de API de Gemini directamente en tu app para Android o la recuperas de forma remota durante el tiempo de ejecución, corres el riesgo de exponerla a personas malintencionadas. Una vez que comiences a desarrollar tu app en serio (y, en especial, para casos de uso de producción), migra para usar Vertex AI en Firebase.

El SDK de cliente de Google AI te permite llamar a la API de Gemini y usar la familia de modelos de Gemini directamente desde tu app para Android.

Un nivel sin costo te permite experimentar sin costo. Para obtener otros detalles sobre los precios, consulta la guía de precios.

Figura 1: Arquitectura de integración de la IA de Google.

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, así como generar una clave de API y configurar tu app para usar el SDK.

Experimenta con instrucciones

Comienza por crear un prototipo de tu instrucción en Google AI Studio.

Google 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 instrucciones en la documentación oficial de Google AI.

Figura 2: Google AI Studio

Para obtener más información sobre las funciones avanzadas de Google AI Studio, consulta la Guía de inicio rápido de Google AI Studio.

Genera tu clave de API

Una vez que estés conforme con la instrucción, haz clic en Obtener clave de API para generar tu clave de API de Gemini. La clave se incluirá en tu aplicación, lo cual es adecuado para la experimentación y la creación de prototipos, pero no se recomienda para casos de uso de producción.

Además, para evitar que tu clave de API se confirme en el repositorio de código fuente, usa el complemento Secrets de Gradle.

Agrega la dependencia de Gradle

Agrega la dependencia del SDK cliente de Google AI a tu app:

Kotlin

dependencies {
  [...]
 implementation("com.google.ai.client.generativeai:generativeai:0.7.0")
}

Java

dependencies {
  [...]
  implementation("com.google.ai.client.generativeai:generativeai:0.7.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")
}

Cómo crear un GenerativeModel

Comienza por crear una instancia de GenerativeModel. Para ello, proporciona lo siguiente:

• El nombre del modelo: gemini-1.5-flash, gemini-1.5-pro o gemini-1.0-pro
• Tu clave de API generada con Google AI Studio

De manera opcional, puedes definir los parámetros del modelo y proporcionar valores para la temperatura, topK, topP y los tokens de salida máximos.

También puedes definir las funciones de seguridad para los siguientes temas:

• HARASSMENT
• HATE_SPEECH
• SEXUALLY_EXPLICIT
• DANGEROUS_CONTENT

Kotlin

val model = GenerativeModel(
  model = "gemini-1.5-flash-001",
  apiKey = BuildConfig.apikey,
  generationConfig = generationConfig {
    temperature = 0.15f
    topK = 32
    topP = 1f
    maxOutputTokens = 4096
  },
  safetySettings = listOf(
    SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE),
  )
)

Java

GenerationConfig.Builder configBuilder = new GenerationConfig.Builder();
configBuilder.temperature = 0.15f;
configBuilder.topK = 32;
configBuilder.topP = 1f;
configBuilder.maxOutputTokens = 4096;

ArrayList<SafetySetting> safetySettings = new ArrayList();
safetySettings.add(new SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE));

GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash-001",
    BuildConfig.apiKey,
    configBuilder.build(),
    safetySettings
);

Usa el SDK cliente de Google AI en tu app

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

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 green robot.")
}

Java

// In Java, create a GenerativeModelFutures from the GenerativeModel.
// generateContent() returns a ListenableFuture.
// Learn more:
// https://developer.android.com/develop/background-work/background-tasks/asynchronous/listenablefuture

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content content = new Content.Builder()
      .addText("Write a story about a green robot.")
      .build();
Executor executor = // ...

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

Ten en cuenta que generateContent() es una función suspend, que se integra bien con el código Kotlin existente.

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

Kotlin

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

Java

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

Executor executor = // ...

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

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

// (Optional) create message history
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);

Content.Builder userMessageBuilder = new Content.Builder();
userMessageBuilder.setRole("user");
userMessageBuilder.addText("How many paws are in my house?");
Content userMessage = userMessageBuilder.build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = chat.sendMessage(userMessage);

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

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

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

Java

// In Java, the method generateContentStream() returns a Publisher
// from the Reactive Streams library.
// https://www.reactive-streams.org/

Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

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);  // Request all messages
 }
});

Android Studio

Android Studio proporciona herramientas adicionales para ayudarte a comenzar.

• Plantilla de partida de la API de Gemini: Esta plantilla de partida te ayuda a crear una clave de API directamente desde Android Studio y genera un proyecto que incluye las dependencias de Android necesarias para usar las APIs de Gemini.
• Ejemplo de IA generativa: Este ejemplo te permite importar el SDK cliente de Google AI para la app de ejemplo de Android en Android Studio.

Próximos pasos

• Revisa la app de ejemplo del SDK cliente de Google AI para Android en GitHub.
• Obtén más información sobre el SDK cliente de Google AI en la documentación oficial de Google AI.