Esta página foi traduzida pela API Cloud Translation.

Vertex AI no Firebase

Para acessar a API Gemini e a família de modelos do Gemini diretamente no seu app, recomendamos usar a Vertex AI no SDK do Firebase para Android. Esse SDK faz parte da plataforma do Firebase, que ajuda a criar e executar apps de stack completa.

Migrar do SDK de cliente da Google AI

O SDK da Vertex AI no Firebase é semelhante ao SDK do cliente da Google AI, mas o SDK da Vertex AI no Firebase oferece opções de segurança essenciais e outros recursos para casos de uso de produção. Por exemplo, ao usar a Vertex AI no Firebase, você também pode usar o seguinte:

Firebase App Check para proteger a API Gemini contra abusos de clientes não autorizados.
Configuração remota do Firebase para definir e mudar valores dinamicamente no app na nuvem (por exemplo, nomes de modelos) sem precisar lancar uma nova versão.
Cloud Storage para Firebase para incluir arquivos de mídia grandes na sua solicitação à API Gemini.

Se você já integrou o SDK do cliente do Google AI ao seu app, é possível migrar para o Vertex AI no Firebase.

Primeiros passos

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

Testar comandos

Você pode testar comandos no Vertex AI Studio. O Vertex 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 solicitações na documentação do Firebase.

Configurar um projeto do Firebase e conectar seu app a ele

Quando estiver tudo pronto para chamar a API Gemini do seu app, siga as instruções no guia de início da Vertex AI no Firebase para configurar o Firebase e o SDK no seu app. O guia de início vai ajudar você a realizar todas as tarefas a seguir neste guia.

Configure um projeto do Firebase novo ou existente, incluindo o uso do plano de preços Blaze de pagamento conforme o uso e a ativação das APIs necessárias.
Conecte seu app ao Firebase, incluindo o registro e a adição do arquivo de configuração do Firebase (google-services.json) ao app.

Adicionar a dependência do Gradle

Adicione a seguinte dependência do Gradle ao módulo do 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")
}

Inicializar o serviço da Vertex AI e o modelo generativo

Comece instanciando um GenerativeModel e especifique o nome do modelo:

Kotlin

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

Java

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

Na documentação do Firebase, você pode saber mais sobre os modelos disponíveis para uso com a Vertex AI no Firebase. Saiba como configurar parâmetros de modelo.

Interagir com a API Gemini no seu app

Agora que você configurou o Firebase e seu app para usar o SDK, é hora de interagir com a API Gemini no seu app.

Gerar texto

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

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

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. Como alternativa, é possível incluir arquivos de mídia grandes em uma solicitação usando URLs do Cloud Storage para o 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 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 = 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);
    }

});

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

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óximas etapas

Analise o app de exemplo do Vertex AI no Firebase no GitHub.
Comece a pensar em se preparar para a produção, incluindo a configuração do Firebase App Check para proteger a API Gemini contra abusos de clientes não autorizados.
Saiba mais sobre a Vertex AI no Firebase na documentação do Firebase.