Streaming bidirecional usando a API Gemini Live

Pré-lançamento: o uso do Gemini Live API com Vertex AI in Firebase está em pré-lançamento. Ou seja, ele não está sujeito a SLAs nem a políticas de descontinuação e pode mudar de maneira incompatível com versões anteriores.

Além disso, na versão inicial, somente o Android e o Flutter têm suporte para usar o Live API. O suporte para plataformas da Apple e para a Web será disponibilizado em breve.

O Gemini Live API permite interações de texto e voz bidirecionais de baixa latência com o Gemini. Com o Live API, você pode oferecer aos usuários finais a experiência de conversas por voz naturais e humanas, com a capacidade de interromper as respostas do modelo usando comandos de texto ou de voz. O modelo pode processar entradas de texto e áudio (o vídeo será lançado em breve) e fornecer saídas de texto e áudio.

É possível criar protótipos com comandos e o Live API em Vertex AI Studio.

O Live API é uma API stateful que cria uma conexão WebSocket para estabelecer uma sessão entre o cliente e o servidor Gemini. Para mais detalhes, consulte a documentação de referência do Live API.

Importante: o Live API tem um limite de taxa de 10 sessões simultâneas por projeto do Firebase. Saiba mais.

Antes de começar

Se ainda não tiver feito isso, conclua o guia de início, que descreve como configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK, inicializar o serviço Vertex AI e criar uma instância LiveModel.

Verifique se você está usando pelo menos estas versões da biblioteca do Firebase:
iOS+: ainda não tem suporte | Android: v16.3.0+ (BoM: v33.12.0+) | Web: ainda não tem suporte | Flutter: v1.5.0+ (BoM: v3.9.0+)

Modelos compatíveis com esse recurso

O Live API é aceito apenas por gemini-2.0-flash-live-preview-04-09, não por gemini-2.0-flash.

Usar os recursos padrão do Live API

Esta seção descreve como usar os recursos padrão do Live API, especificamente para transmitir vários tipos de entradas e saídas:

• Enviar e receber mensagens de texto
• Enviar e receber áudio
• Enviar áudio e receber texto
• Enviar texto e receber áudio

Enviar e receber mensagens de texto

É possível enviar entradas de texto em streaming e receber saídas de texto em streaming. Crie uma instância liveModel e defina a modalidade de resposta como Text.

Swift

O Live API ainda não é compatível com apps para a plataforma Apple, mas volte em breve.

Kotlin

// Initialize the Vertex AI service and create a `LiveModel` instance
val model = Firebase.vertexAI.liveModel(
    // The Live API requires this specific model.
    modelName = "gemini-2.0-flash-live-preview-04-09",
    // Configure the model to respond with text
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.TEXT 
   }
)

val session = model.connect()

// Provide a text prompt
val text = "tell a short story"

session.send(text)

var outputText = ""
session.receive().collect {
    if(it.status == Status.TURN_COMPLETE) {
        // Optional: if you don't require to send more requests.
        session.stopReceiving();
    }
    outputText = outputText + it.text
}

// Output received from the server.
println(outputText)

Java

ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Vertex AI service and create a `LiveModel` instance
LiveGenerativeModel lm = FirebaseVertexAI.getInstance().liveModel(
        // The Live API requires this specific model.
        "gemini-2.0-flash-live-preview-04-09",
        // Configure the model to respond with text
        new LiveGenerationConfig.Builder()
                .setResponseModalities(ResponseModality.TEXT)
                .build()
);
LiveModelFutures model = LiveModelFutures.from(lm);
ListenableFuture<LiveSession> sessionFuture =  model.connect();
class LiveContentResponseSubscriber implements Subscriber<LiveContentResponse> {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE); // Request an unlimited number of items
    }
    @Override
    public void onNext(LiveContentResponse liveContentResponse) {
       // Handle the response from the server.
	System.out.println(liveContentResponse.getText());
    }
    @Override
    public void onError(Throwable t) {
        System.err.println("Error: " + t.getMessage());
    }
    @Override
    public void onComplete() {
        System.out.println("Done receiving messages!");
    }
}
Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	  LiveSessionFutures session = LiveSessionFutures.from(ses);
        // Provide a text prompt
        String text = "tell me a short story?";
        session.send(text);
        Publisher<LiveContentResponse> publisher = session.receive();
        publisher.subscribe(new LiveContentResponseSubscriber());
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

O Live API ainda não é compatível com apps da Web, mas volte em breve.

Dart

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

late LiveModelSession _session;

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

// Initialize the Vertex AI service and create a `LiveModel` instance
final model = FirebaseVertexAI.instance.liveModel(
  // The Live API requires this specific model.
  model: 'gemini-2.0-flash-live-preview-04-09',
  // Configure the model to respond with text
  config: LiveGenerationConfig(responseModalities: [ResponseModality.text]),
);

_session = await model.connect();

// Provide a text prompt
final prompt = Content.text('tell a short story');
await _session.send(input: prompt, turnComplete: true);

// In a separate thread, receive the response
await for (final message in _session.receive()) {
   // Process the received message 
}

Saiba como escolher um modelo e, opcionalmente, um local adequado para seu caso de uso e app.

Enviar e receber áudio

É possível enviar entrada de áudio por streaming e receber saída de áudio por streaming. Crie uma instância LiveModel e defina a modalidade de resposta como Audio.

Saiba como configurar e personalizar a voz de resposta (mais adiante nesta página).

Swift

O Live API ainda não é compatível com apps para a plataforma Apple, mas volte em breve.

Kotlin

// Initialize the Vertex AI service and create a `LiveModel` instance
val model = Firebase.vertexAI.liveModel(
    // The Live API requires this specific model.
    modelName = "gemini-2.0-flash-live-preview-04-09",
    // Configure the model to respond with text
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO 
   }
)

val session = model.connect()

// This is the recommended way.
// However, you can create your own recorder and handle the stream.
session.startAudioConversation()

Java

ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Vertex AI service and create a `LiveModel` instance
LiveGenerativeModel lm = FirebaseVertexAI.getInstance().liveModel(
        // The Live API requires this specific model.
        "gemini-2.0-flash-live-preview-04-09",
        // Configure the model to respond with text
        new LiveGenerationConfig.Builder()
                .setResponseModalities(ResponseModality.TEXT)
                .build()
);
LiveModelFutures model = LiveModelFutures.from(lm);
ListenableFuture<LiveSession> sessionFuture =  model.connect();

Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	 LiveSessionFutures session = LiveSessionFutures.from(ses);
        session.startAudioConversation();
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

O Live API ainda não é compatível com apps da Web, mas volte em breve.

Dart

import 'package:firebase_vertexai/firebase_vertexai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'package:your_audio_recorder_package/your_audio_recorder_package.dart';

late LiveModelSession _session;
final _audioRecorder = YourAudioRecorder();

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

// Initialize the Vertex AI service and create a `LiveModel` instance
final model = FirebaseVertexAI.instance.liveModel(
  // The Live API requires this specific model.
  model: 'gemini-2.0-flash-live-preview-04-09',
   // Configure the model to respond with audio
   config: LiveGenerationConfig(responseModalities: [ResponseModality.audio]),
);

_session = await model.connect();

final audioRecordStream = _audioRecorder.startRecordingStream();
// Map the Uint8List stream to InlineDataPart stream
final mediaChunkStream = audioRecordStream.map((data) {
  return InlineDataPart('audio/pcm', data);
});
await _session.startMediaStream(mediaChunkStream);

// In a separate thread, receive the audio response from the model
await for (final message in _session.receive()) {
   // Process the received message 
}

Saiba como escolher um modelo e, opcionalmente, um local adequado para seu caso de uso e app.

Enviar áudio e receber texto

É possível enviar entrada de áudio em streaming e receber saída de texto em streaming. Crie uma instância LiveModel e defina a modalidade de resposta como Text.

Swift

O Live API ainda não é compatível com apps para plataformas da Apple, mas volte em breve.

Kotlin

// Initialize the Vertex AI service and create a `LiveModel` instance
val model = Firebase.vertexAI.liveModel(
    // The Live API requires this specific model.
    modelName = "gemini-2.0-flash-live-preview-04-09",
    // Configure the model to respond with text
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.TEXT 
   }
)

val session = model.connect()

// Provide a text prompt
val audioContent = content("user") { audioData }

session.send(audioContent)

var outputText = ""
session.receive().collect {
    if(it.status == Status.TURN_COMPLETE) {
        // Optional: if you don't require to send more requests.
        session.stopReceiving();
    }
    outputText = outputText + it.text
}

// Output received from the server.
println(outputText)

Java

TODO - snippet ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Vertex AI service and create a `LiveModel` instance
LiveGenerativeModel lm = FirebaseVertexAI.getInstance().liveModel(
        // The Live API requires this specific model.
        "gemini-2.0-flash-live-preview-04-09",
        // Configure the model to respond with text
        new LiveGenerationConfig.Builder()
                .setResponseModalities(ResponseModality.TEXT)
                .build()
);
LiveModelFutures model = LiveModelFutures.from(lm);
ListenableFuture<LiveSession> sessionFuture =  model.connect();
class LiveContentResponseSubscriber implements Subscriber<LiveContentResponse> {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE); // Request an unlimited number of items
    }
    @Override
    public void onNext(LiveContentResponse liveContentResponse) {
        // Handle the response from the server.
	System.out.println(liveContentResponse.getText());
    }
    @Override
    public void onError(Throwable t) {
        System.err.println("Error: " + t.getMessage());
    }
    @Override
    public void onComplete() {
        System.out.println("Done receiving messages!");
    }
}
Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	 LiveSessionFutures session = LiveSessionFutures.from(ses);
        // Send Audio data
	 session.send(new Content.Builder().addInlineData(audioData, "audio/pcm").build());

        session.send(text);
        Publisher<LiveContentResponse> publisher = session.receive();
        publisher.subscribe(new LiveContentResponseSubscriber());
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

O Live API ainda não é compatível com apps da Web, mas volte em breve.

Dart

import 'package:firebase_vertexai/firebase_vertexai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'package:your_audio_recorder_package/your_audio_recorder_package.dart';
import 'dart:async';

late LiveModelSession _session;
final _audioRecorder = YourAudioRecorder();

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

final model = FirebaseVertexAI.instance.liveModel(
  model: 'gemini-2.0-flash-live-preview-04-09',
  config: LiveGenerationConfig(responseModality: ResponseModality.text),
);

_session = await model.connect();

final audioRecordStream = _audioRecorder.startRecordingStream();
final mediaChunkStream = audioRecordStream.map((data) {
  return InlineDataPart('audio/pcm', data);
});

await _session.startMediaStream(mediaChunkStream);

final responseStream = _session.receive();

return responseStream.asyncMap((response) async {
  if (response.parts.isNotEmpty && response.parts.first.text != null) {
    return response.parts.first.text!;
  } else {
    throw Exception('Text response not found.');
  }
});

Future main() async {
  try {
    final textStream = await audioToText();

    await for (final text in textStream) {
      print('Received text: $text');
      // Handle the text response
    }
  } catch (e) {
    print('Error: $e');
  }
}

Saiba como escolher um modelo e, opcionalmente, um local adequado para seu caso de uso e app.

Enviar texto e receber áudio

É possível enviar entrada de texto por streaming e receber saída de áudio por streaming. Crie uma instância LiveModel e defina a modalidade de resposta como Audio.

Saiba como configurar e personalizar a voz de resposta (mais adiante nesta página).

Swift

O Live API ainda não é compatível com apps para a plataforma Apple, mas volte em breve.

Kotlin

// Initialize the Vertex AI service and create a `LiveModel` instance
val model = Firebase.vertexAI.liveModel(
    // The Live API requires this specific model.
    modelName = "gemini-2.0-flash-live-preview-04-09",
    // Configure the model to respond with text
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
   }
)

val session = model.connect()

// Provide a text prompt
val text = "tell a short story"

session.send(text)

session.receive().collect {
    if(it.status == Status.TURN_COMPLETE) {
        // Optional: if you don't require to send more requests.
        session.stopReceiving();
    }
    // Handle 16bit pcm audio data at 24khz
    playAudio(it.data)
}

Java

ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Vertex AI service and create a `LiveModel` instance
LiveGenerativeModel lm = FirebaseVertexAI.getInstance().liveModel(
        // The Live API requires this specific model.
        "gemini-2.0-flash-live-preview-04-09",
        // Configure the model to respond with text
        new LiveGenerationConfig.Builder()
                .setResponseModalities(ResponseModality.AUDIO)
                .build()
);
LiveModelFutures model = LiveModelFutures.from(lm);
ListenableFuture<LiveSession> sessionFuture =  model.connect();
class LiveContentResponseSubscriber implements Subscriber<LiveContentResponse> {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE); // Request an unlimited number of items
    }
    @Override
    public void onNext(LiveContentResponse liveContentResponse) {
        // Handle 16bit pcm audio data at 24khz
	liveContentResponse.getData();
    }
    @Override
    public void onError(Throwable t) {
        System.err.println("Error: " + t.getMessage());
    }
    @Override
    public void onComplete() {
        System.out.println("Done receiving messages!");
    }
}
Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	 LiveSessionFutures session = LiveSessionFutures.from(ses);
        // Provide a text prompt
        String text = "tell me a short story?";
        session.send(text);
        Publisher<LiveContentResponse> publisher = session.receive();
        publisher.subscribe(new LiveContentResponseSubscriber());
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

O Live API ainda não é compatível com apps da Web, mas volte em breve.

Dart

import 'package:firebase_vertexai/firebase_vertexai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'dart:async';
import 'dart:typed_data';

late LiveModelSession _session;

Future<Stream<Uint8List>> textToAudio(String textPrompt) async {
  WidgetsFlutterBinding.ensureInitialized();

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

  final model = FirebaseVertexAI.instance.liveModel(
    model: 'gemini-2.0-flash-live-preview-04-09',
    config: LiveGenerationConfig(responseModality: ResponseModality.audio),
  );

  _session = await model.connect();

  final prompt = Content.text(textPrompt);

  await _session.send(input: prompt);

  return _session.receive().asyncMap((response) async {
    if (response is LiveServerContent && response.modelTurn?.parts != null) {
       for (final part in response.modelTurn!.parts) {
         if (part is InlineDataPart) {
           return part.bytes;
         }
       }
    }
    throw Exception('Audio data not found');
  });
}

Future<void> main() async {
  try {
    final audioStream = await textToAudio('Convert this text to audio.');

    await for (final audioData in audioStream) {
      // Process the audio data (e.g., play it using an audio player package)
      print('Received audio data: ${audioData.length} bytes');
      // Example using flutter_sound (replace with your chosen package):
      // await _flutterSoundPlayer.startPlayer(fromDataBuffer: audioData);
    }
  } catch (e) {
    print('Error: $e');
  }
}

Saiba como escolher um modelo e, opcionalmente, um local adequado para seu caso de uso e app.

---

Crie experiências mais envolventes e interativas

Esta seção descreve como criar e gerenciar recursos mais envolventes ou interativos do Live API.

Mudar a voz da resposta

O Live API usa o Chirp 3 para oferecer suporte a respostas de fala sintetizadas. Ao usar Vertex AI in Firebase, é possível enviar áudio em cinco vozes HD e 31 idiomas.

Observação: Vertex AI in Firebase ainda não oferece suporte para definir um idioma de resposta ou usar as seguintes vozes: Leda, Orus ou Zephyr. Volte em breve.

Se você não especificar uma voz, o padrão será Puck. Também é possível configurar o modelo para responder em qualquer um dos seguintes idiomas:

Aoede (feminino) Charon (masculino)

Fenrir (masculino) Kore (feminino)

Puck (masculino)

Para conferir demonstrações de como essas vozes soam e a lista completa de idiomas disponíveis, consulte Chirp 3: vozes em alta definição.

Para especificar uma voz, defina o nome da voz no objeto speechConfig como parte da configuração do modelo:

Swift

O Live API ainda não é compatível com apps para a plataforma Apple, mas volte em breve.

Kotlin

// ...

val model = Firebase.vertexAI.liveModel(
    modelName = "gemini-2.0-flash-live-preview-04-09",
    // Configure the model to use a specific voice for its audio response
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
        speechConfig = SpeechConfig(voice = Voices.FENRIR)
    }
)

// ...

Java

// ...

LiveModel model = Firebase.getVertexAI().liveModel(
    "gemini-2.0-flash-live-preview-04-09",
    // Configure the model to use a specific voice for its audio response
    new LiveGenerationConfig.Builder()
        .setResponseModalities(ResponseModality.AUDIO)
        .setSpeechConfig(new SpeechConfig(Voices.FENRIR))
        .build()
);

// ...

Web

O Live API ainda não é compatível com apps da Web, mas volte em breve.

Dart

// ...

final model = FirebaseVertexAI.instance.liveModel(
  model: 'gemini-2.0-flash-live-preview-04-09',
  // Configure the model to use a specific voice for its audio response
  config: LiveGenerationConfig(
    responseModality: ResponseModality.audio,
    speechConfig: SpeechConfig(voice: Voice.fenrir),
  ),
);

// ...

Para melhores resultados ao solicitar e exigir que o modelo responda em um idioma diferente do inglês, inclua o seguinte como parte das instruções do sistema:

RESPOND IN LANGUAGE. YOU MUST RESPOND UNMISTAKABLY IN LANGUAGE.

Observação: Vertex AI in Firebase não oferece suporte à atualização de instruções do sistema durante a sessão ou a resposta.

Manter o contexto em sessões e solicitações

Você pode usar uma estrutura de chat para manter o contexto em todas as sessões e solicitações. Isso só funciona para entrada e saída de texto.

Essa abordagem é melhor para contextos curtos. Você pode enviar interações passo a passo para representar a sequência exata de eventos. Para contextos mais longos, recomendamos fornecer um único resumo de mensagem para liberar a janela de contexto para interações subsequentes.

Processar interrupções

Vertex AI in Firebase ainda não oferece suporte ao processamento de interrupções. Verifique novamente mais tarde.

Usar chamada de função (ferramentas)

É possível definir ferramentas, como funções disponíveis, para usar com a API Live, assim como nos métodos padrão de geração de conteúdo. Esta seção descreve algumas nuances ao usar a API Live com chamadas de função. Para uma descrição completa e exemplos de chamadas de função, consulte o guia de chamadas de função.

Importante: as entradas e saídas de áudio podem afetar negativamente a capacidade do modelo de usar a chamada de função.

Com um único comando, o modelo pode gerar várias chamadas de função e o código necessário para encadear as saídas. Esse código é executado em um ambiente de sandbox, gerando mensagens BidiGenerateContentToolCall posteriores. A execução é pausada até que os resultados de cada chamada de função estejam disponíveis, o que garante o processamento sequencial.

Além disso, o uso da API Live com a chamada de função é particularmente poderoso, porque o modelo pode solicitar informações de acompanhamento ou esclarecimentos do usuário. Por exemplo, se o modelo não tiver informações suficientes para fornecer um valor de parâmetro a uma função que ele quer chamar, o modelo poderá pedir ao usuário que forneça mais informações ou informações mais claras.

O cliente precisa responder com BidiGenerateContentToolResponse.

---

Limitações e requisitos

Considere as seguintes limitações e requisitos do Live API.

Transcrição

O Vertex AI in Firebase ainda não oferece suporte a transcrições. Verifique novamente mais tarde.

Idiomas

• Idiomas de entrada:confira a lista completa de idiomas de entrada com suporte para modelos Gemini.
• Idiomas de saída:confira a lista completa de idiomas de saída disponíveis em Chirp 3: vozes em alta definição.

Formatos de áudio

O Live API oferece suporte aos seguintes formatos de áudio:

• Formato de áudio de entrada:áudio PCM bruto de 16 bits a 16 kHz little-endian
• Formato de áudio de saída:áudio PCM bruto de 16 bits em little-endian de 24 kHz

Limites de taxas

Os seguintes limites de taxa se aplicam:

• 10 sessões simultâneas por projeto do Firebase
• 4 milhões de tokens por minuto

Duração da sessão

A duração padrão de uma sessão é de 30 minutos. Quando a duração da sessão ultrapassa o limite, a conexão é encerrada.

O modelo também é limitado pelo tamanho do contexto. O envio de grandes quantidades de entrada pode resultar no encerramento antecipado da sessão.

Detecção de atividade de voz (VAD)

O modelo realiza automaticamente a detecção de atividade de voz (VAD, na sigla em inglês) em um fluxo de entrada de áudio contínuo. O VAD está ativado por padrão.

Observação: o Vertex AI in Firebase ainda não oferece suporte à desativação do VAD ou à configuração dos parâmetros do VAD.

Contagem de tokens

Não é possível usar a API CountTokens com o Live API.