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