Comece a usar a API Gemini com os SDKs de lógica de IA do Firebase

Este guia mostra como começar a fazer chamadas para o Gemini API diretamente do seu app usando os SDKs do cliente Firebase AI Logic para a plataforma escolhida.

Você também pode usar este guia para começar a acessar modelos do Imagen usando os SDKs do Firebase AI Logic.

O Firebase AI Logic e os SDKs de cliente dele eram chamados de "Vertex AI in Firebase". Em maio de 2025, renomeamos e reorganizamos nossos serviços em Firebase AI Logic para refletir melhor nossos serviços e recursos expandidos. Por exemplo, agora oferecemos suporte ao Gemini Developer API!

Pré-requisitos

Swift

Neste guia, pressupomos que você já sabe usar o Xcode para desenvolver apps para plataformas da Apple (como o iOS).

• Verifique se o ambiente de desenvolvimento e o app para plataformas Apple atendem a estes requisitos:

  • Xcode 16.2 ou versões mais recentes
  • O app é direcionado ao iOS 15 ou mais recente ou ao macOS 12 ou mais recente.

• (Opcional) Confira o app de exemplo.

  Baixe o app de início rápido

  Você pode testar o SDK rapidamente, conferir uma implementação completa de vários casos de uso ou usar o app de exemplo se não tiver um app próprio para plataformas Apple. Para usar o app de exemplo, conecte-o a um projeto do Firebase.

Kotlin

Neste guia, pressupomos que você já sabe usar o Android Studio para desenvolver apps para Android.

• Verifique se o ambiente de desenvolvimento e o app Android atendem a estes requisitos:

  • Android Studio (versão mais recente)
  • O app é direcionado à API de nível 21 ou mais recente.

• (Opcional) Confira o app de exemplo.

  Fazer o download do app de exemplo

  Você pode testar o SDK rapidamente, conferir uma implementação completa de vários casos de uso ou usar o app de exemplo se não tiver um app Android próprio. Para usar o app de exemplo, conecte-o a um projeto do Firebase.

Java

Neste guia, pressupomos que você já sabe usar o Android Studio para desenvolver apps para Android.

• Verifique se o ambiente de desenvolvimento e o app Android atendem a estes requisitos:

  • Android Studio (versão mais recente)
  • O app é direcionado à API de nível 21 ou mais recente.

• (Opcional) Confira o app de exemplo.

  Fazer o download do app de exemplo

  Você pode testar o SDK rapidamente, conferir uma implementação completa de vários casos de uso ou usar o app de exemplo se não tiver um app Android próprio. Para usar o app de exemplo, conecte-o a um projeto do Firebase.

Web

Neste guia, pressupomos que você já sabe usar o JavaScript para desenvolver apps da Web. Este guia não depende da estrutura.

• Verifique se o ambiente de desenvolvimento e o app da Web atendem a estes requisitos:

  • (Opcional) Node.js
  • Navegador da Web moderno

• (Opcional) Confira o app de exemplo.

  Fazer o download do app de exemplo

  Você pode testar o SDK rapidamente, conferir uma implementação completa de vários casos de uso ou usar o app de exemplo se não tiver um app da Web próprio. Para usar o app de exemplo, conecte-o a um projeto do Firebase.

Dart

Neste guia, pressupomos que você já sabe desenvolver apps com o Flutter.

• Verifique se o ambiente de desenvolvimento e o app Flutter atendem a estes requisitos:

  • Dart 3.2.0+

• (Opcional) Confira o app de exemplo.

  Fazer o download do app de exemplo

  Você pode testar o SDK rapidamente, conferir uma implementação completa de vários casos de uso ou usar o app de exemplo se não tiver um app Flutter próprio. Para usar o app de exemplo, conecte-o a um projeto do Firebase.

Unity

Neste guia, pressupomos que você já sabe desenvolver jogos com o Unity.

• Verifique se o ambiente de desenvolvimento e o jogo do Unity atendem a estes requisitos:

  • Unity Editor 2021 LTS ou mais recente

• (Opcional) Confira o app de exemplo.

  Fazer o download do app de exemplo

  Você pode testar o SDK rapidamente, conferir uma implementação completa de vários casos de uso ou usar o app de exemplo se não tiver seu próprio jogo do Unity. Para usar o app de exemplo, você precisa conectá-lo a um projeto do Firebase.

Etapa 1: configurar um projeto do Firebase e conectar seu app

1. Faça login no console do Firebase e selecione seu projeto do Firebase.

   Ainda não tem um projeto do Firebase?

   Se você ainda não tem um projeto do Firebase, clique em Criar projeto e use uma das seguintes opções:

   • Opção 1: crie um projeto do Firebase totalmente novo (e o projeto do Google Cloud automaticamente) inserindo um novo nome na primeira etapa do fluxo de trabalho "Criar projeto".

   • Opção 2: "Adicionar o Firebase" a um projeto Google Cloud existente selecionando o nome do projeto Google Cloud no menu suspenso da primeira etapa do fluxo de trabalho "Criar projeto".

   Quando solicitado, você não vai precisar configurar o Google Analytics para usar os SDKs do Firebase AI Logic.

2. No console Firebase, acesse a página Firebase AI Logic.

3. Clique em Começar para iniciar um fluxo de trabalho guiado que ajuda a configurar as APIs necessárias e os recursos do projeto.

4. Selecione o provedor "Gemini API" que você quer usar com os SDKs Firebase AI Logic. Você pode configurar e usar o outro provedor de API mais tarde, se quiser.

   • Gemini Developer API: faturamento opcional (disponível no plano de preços Spark sem custos financeiros, e você pode fazer upgrade depois, se quiser)
     . O console vai ativar as APIs necessárias e criar uma chave de API Gemini no seu projeto.
     Não adicione essa chave de API Gemini à base de código do seu app. Saiba mais.

   • Vertex AI Gemini API: faturamento obrigatório (requer o plano de preços Blaze de pagamento por uso)
     . O console ajuda você a configurar o faturamento e ativar as APIs necessárias no seu projeto.

5. Se solicitado no fluxo de trabalho do console, siga as instruções na tela para registrar seu app e conectá-lo ao Firebase.

6. Continue para a próxima etapa deste guia e adicione o SDK ao app.

Observação: no console Firebase, recomendamos configurar Firebase App Check. Se você estiver apenas testando o Gemini API, não é necessário configurar o App Check imediatamente. No entanto, recomendamos fazer isso assim que você começar a desenvolver seu app.

Etapa 2: adicionar o SDK

Com o projeto do Firebase configurado e o app conectado ao Firebase (consulte a etapa anterior), agora é possível adicionar o SDK Firebase AI Logic ao app.

Swift

Use o Swift Package Manager para instalar e gerenciar as dependências do Firebase.

Observação: acesse nosso guia de instalação para saber sobre as diferentes maneiras de adicionar SDKs do Firebase ao seu projeto da Apple, incluindo a importação direta de frameworks e o uso do CocoaPods.

A biblioteca Firebase AI Logic oferece acesso às APIs para interagir com modelos Gemini e Imagen. A biblioteca está incluída como parte do SDK do Firebase para plataformas Apple (firebase-ios-sdk).

Se você já usa o Firebase, verifique se o pacote dele é v11.13.0 ou mais recente.

1. No Xcode, com seu projeto do app aberto, navegue até Arquivo > Adicionar dependências do pacote.

2. Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:

   https://github.com/firebase/firebase-ios-sdk
   

3. Selecione a versão mais recente do SDK.

4. Selecione a biblioteca FirebaseAI.

Quando terminar, o Xcode vai começar a resolver e fazer o download das dependências em segundo plano automaticamente.

Kotlin

O SDK do Firebase AI Logic Android (firebase-ai) oferece acesso às APIs para interagir com modelos Gemini e Imagen.

No arquivo Gradle do módulo (nível do app) (como <project>/<app-module>/build.gradle.kts), adicione a dependência da biblioteca Firebase AI Logic para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versões da biblioteca.

dependencies {
  // ... other androidx dependencies

  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:firebase-bom:33.15.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")
}

Com o Firebase Android BoM, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

(Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar o BoM

Se você preferir não usar a BoM do Firebase BoM, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

Se você usa várias bibliotecas do Firebase no seu app, recomendamos usar o BoM para gerenciar as versões delas e garantir a compatibilidade de todas.

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

Java

O SDK do Firebase AI Logic Android (firebase-ai) oferece acesso às APIs para interagir com modelos Gemini e Imagen.

No arquivo Gradle do módulo (nível do app) (como <project>/<app-module>/build.gradle.kts), adicione a dependência da biblioteca Firebase AI Logic para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versões da biblioteca.

Para Java, é necessário adicionar duas bibliotecas extras.

dependencies {
  // ... other androidx dependencies

  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:firebase-bom:33.15.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")
}

Com o Firebase Android BoM, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

(Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar o BoM

Se você preferir não usar a BoM do Firebase BoM, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

Se você usa várias bibliotecas do Firebase no seu app, recomendamos usar o BoM para gerenciar as versões delas e garantir a compatibilidade de todas.

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

Web

A biblioteca Firebase AI Logic oferece acesso às APIs para interagir com modelos Gemini e Imagen. A biblioteca está incluída como parte do SDK do Firebase para JavaScript para Web.

1. Instale o SDK do Firebase para JavaScript para Web usando o npm:

   npm install firebase
   

2. Inicialize o Firebase no seu app:

   import { initializeApp } from "firebase/app";
   
   // TODO(developer) Replace the following with your app's Firebase configuration
   // See: https://firebase.google.com/docs/web/learn-more#config-object
   const firebaseConfig = {
     // ...
   };
   
   // Initialize FirebaseApp
   const firebaseApp = initializeApp(firebaseConfig);
   

Dart

O plug-in Firebase AI Logic para Flutter (firebase_ai) oferece acesso às APIs para interagir com os modelos Gemini e Imagen.

1. No diretório do projeto do Flutter, execute o seguinte comando para instalar o plug-in principal e o plug-in do Firebase AI Logic:

   flutter pub add firebase_core && flutter pub add firebase_ai
   

2. No arquivo lib/main.dart, importe o plug-in principal do Firebase, o plug-in Firebase AI Logic e o arquivo de configuração gerado antes:

   import 'package:firebase_core/firebase_core.dart';
   import 'package:firebase_ai/firebase_ai.dart';
   import 'firebase_options.dart';
   

3. Ainda no arquivo lib/main.dart, inicialize o Firebase usando o objeto DefaultFirebaseOptions exportado pelo arquivo de configuração:

   await Firebase.initializeApp(
     options: DefaultFirebaseOptions.currentPlatform,
   );
   

4. Recrie o aplicativo do Flutter:

   flutter run
   

Unity

1. Faça o download do SDK do Firebase Unity e extraia o SDK em um local prático.

   O SDK do Firebase para Unity não é específico de nenhuma plataforma.

2. No seu projeto aberto do Unity, acesse Assets > Import Package > Custom Package.

3. No SDK extraído, selecione o pacote FirebaseAI.

4. Na janela Import Unity Package, clique em Import.

5. De volta ao fluxo de trabalho de configuração no Console do Firebase, clique em Avançar.

Etapa 3: inicializar o serviço e criar uma instância de modelo

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página. API Gemini Developer API Gemini da Vertex AI

Antes de enviar um comando para um modelo Gemini, inicialize o serviço para o provedor de API escolhido e crie uma instância GenerativeModel.

Swift

import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.5-flash")

Kotlin

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")

Java

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

Web

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" });

Dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');

Unity

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash");

Dependendo da capacidade que você está usando, talvez nem sempre seja necessário criar uma instância GenerativeModel.

• Para acessar um modelo Imagen, crie uma instância ImagenModel.

Além disso, depois de concluir este guia de início rápido, aprenda a escolher um modelo para seu caso de uso e app.

Etapa 4: enviar uma solicitação de comando a um modelo

Agora você está pronto para enviar uma solicitação de comando a um modelo Gemini.

Você pode usar generateContent() para gerar texto com base em um comando que contém texto:

Swift

import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.5-flash")

// Provide a prompt that contains text
let prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
let response = try await model.generateContent(prompt)
print(response.text ?? "No text in response.")

Kotlin

^{Para Kotlin, os métodos neste SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")

// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = generativeModel.generateContent(prompt)
print(response.text)

Java

^{Para Java, os métodos neste SDK retornam um ListenableFuture.}

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
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);

Web

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" });

// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call generateContent with the text input
  const result = await model.generateContent(prompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');

// Provide a prompt that contains text
final prompt = [Content.text('Write a story about a magic backpack.')];

// To generate text output, call generateContent with the text input
final response = await model.generateContent(prompt);
print(response.text);

Unity

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash");

// Provide a prompt that contains text
var prompt = "Write a story about a magic backpack.";

// To generate text output, call GenerateContentAsync with the text input
var response = await model.GenerateContentAsync(prompt);
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

O Gemini API também pode transmitir respostas para interações mais rápidas, além de processar comandos multimodais que incluem conteúdo como imagens, vídeos, áudio e PDFs. Mais adiante nesta página, você encontra links para guias sobre várias funcionalidades do Gemini API.

O que mais você sabe fazer?

Saiba mais sobre os modelos compatíveis

Saiba mais sobre os modelos disponíveis para vários casos de uso e as respectivas cotas e preços.

Testar outros recursos

• Saiba mais sobre como gerar texto com comandos somente de texto, incluindo como transmitir a resposta.
• Gere texto usando comandos com vários tipos de arquivos, como imagens, PDFs, vídeos e áudios.
• Crie conversas multiturno (chat).
• Gerar saída estruturada (como JSON) com base em comandos de texto e multimodais.
• Gerar imagens com base em comandos de texto (Gemini ou Imagen).
• Entrada e saída de stream (incluindo áudio) usando o Gemini Live API.
• Use a chamada de função para conectar modelos generativos a sistemas e informações externas.

Saiba como controlar a geração de conteúdo

• Entenda o design de comandos, incluindo práticas recomendadas, estratégias e exemplos de comandos.
• Configure parâmetros do modelo, como temperatura e máximo de tokens de saída (para Gemini) ou proporção e geração de pessoas (para Imagen).
• Use as configurações de segurança para ajustar a probabilidade de receber respostas que possam ser consideradas prejudiciais.

Você também pode testar comandos e configurações de modelo e até mesmo receber um snippet de código gerado usando Google AI Studio.

Enviar feedback sobre sua experiência com Firebase AI Logic