SDK do cliente da IA do Google

O SDK de cliente da IA do Google permite chamar a API Gemini e usar a família de modelos diretamente no seu app Android.

Com um nível sem custo financeiro, você pode testar sem custos. Para outros detalhes de preços, consulte o guia de preços.

Arquitetura de integração da IA do Google
Figura 1. Arquitetura de integração da IA do Google.

Primeiros passos

Antes de interagir com a API Gemini diretamente no app, você precisa fazer algumas coisas, incluindo se familiarizar com a solicitação, gerar uma chave de API e configurar o app para usar o SDK.

Testar comandos

Comece criando um protótipo da solicitação no Google AI Studio.

O Google AI Studio é um ambiente de desenvolvimento integrado para design de comandos e prototipagem. Ele permite fazer upload de arquivos para testar comandos com texto e imagens e salvar um comando para revisitar mais tarde.

Criar a solicitação certa para seu caso de uso é mais arte do que ciência, o que torna a experimentação fundamental. Saiba mais sobre comandos na documentação oficial da IA do Google.

Google AI Studio
Figura 2. Google AI Studio

Para saber mais sobre os recursos avançados do Google AI Studio, consulte o Guia de início rápido do Google AI Studio.

Gerar a chave de API

Quando estiver satisfeito com a solicitação, clique em Receber chave de API para gerar a chave da API Gemini. A chave será incluída no seu aplicativo, o que é aceitável para experimentação e prototipagem, mas não é recomendado para casos de uso de produção.

Além disso, para evitar que a chave de API seja confirmada no repositório de código-fonte, use o plug-in Secrets do Gradle.

Adicionar a dependência do Gradle

Adicione a dependência do SDK do cliente da Google AI ao seu 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")
}

Criar um GenerativeModel.

Comece instanciando um GenerativeModel fornecendo o seguinte:

  • O nome do modelo: gemini-1.5-flash, gemini-1.5-pro ou gemini-1.0-pro
  • Sua chave de API gerada com o Google AI Studio.

Você pode definir os parâmetros do modelo e fornecer valores para temperatura, topK, topP e os tokens de saída máximos.

Também é possível definir os recursos de segurança para os seguintes tópicos:

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

Usar o SDK do cliente da Google AI no seu app

Agora que você tem uma chave de API e configurou o app para usar o SDK, está tudo pronto para interagir com a API Gemini.

Gerar texto

Para gerar uma resposta de texto, chame generateContent() com o comando.

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

generateContent() é uma função suspend, que se integra bem ao código Kotlin.

Gerar texto com base em imagens e outras mídias

Também é possível gerar texto a partir de um comando que inclui texto, imagens ou outras mídias. Ao chamar generateContent(), você pode transmitir a mídia como dados inline, conforme mostrado no exemplo abaixo.

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 multiturno

Você também pode oferecer suporte a conversas com vários turnos. Inicialize uma conversa com a função startChat(). Você pode fornecer um histórico de mensagens. Em seguida, chame a função sendMessage() para enviar mensagens 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);

Transmitir a resposta

É possível conseguir interações mais rápidas sem esperar pelo resultado completo da geração do modelo e, em vez disso, usar o streaming para processar resultados parciais. Use generateContentStream() para transmitir uma resposta.

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

O Android Studio oferece outras ferramentas para ajudar você a começar.

  • Modelo inicial da API Gemini: esse modelo inicial ajuda a criar uma chave de API diretamente no Android Studio e gera um projeto que inclui as dependências do Android necessárias para usar as APIs Gemini.
  • Exemplo de IA generativa: permite importar o SDK de cliente da Google AI para o app de exemplo do Android no Android Studio.

Próximas etapas