Streaming bidirecional usando a API Gemini Live



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.

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 tem suporte apenas para gemini-2.0-flash-live-preview-04-09, não para 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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

// ...

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

// ...
// ...

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

// ...

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.

Manter o contexto em todas as 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 chamadas 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.

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

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

Contagem de tokens

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