Gemini Live API consente interazioni bidirezionali a bassa latenza con Gemini tramite testo e voce. Utilizzando Live API, puoi offrire agli utenti finali l'esperienza di conversazioni vocali naturali e simili a quelle umane, con la possibilità di interrompere le risposte del modello utilizzando comandi vocali o di testo. Il modello può elaborare input di testo e audio (i video saranno disponibili a breve) e può fornire output di testo e audio.
Puoi creare prototipi con i prompt e Live API in Vertex AI Studio.
Live API è un'API stateful che crea una connessione WebSocket per stabilire una sessione tra il client e il server Gemini. Per maggiori dettagli, consulta la documentazione di riferimento di Live API.
Prima di iniziare
Disponibile solo quando utilizzi Vertex AI Gemini API come provider API. |
Se non l'hai ancora fatto, completa la guida introduttiva, che descrive come configurare il progetto Firebase, connettere l'app a Firebase, aggiungere l'SDK, inizializzare il servizio di backend per Vertex AI Gemini API e creare un'istanza LiveModel
.
Modelli che supportano questa funzionalità
Live API è supportato solo da gemini-2.0-flash-live-preview-04-09
(non da gemini-2.0-flash
).
Tieni inoltre presente che gemini-2.0-flash-live-preview-04-09
è supportato solo nella località
us-central1
.
Utilizza le funzionalità standard di Live API
Questa sezione descrive come utilizzare le funzionalità standard di Live API, in particolare per lo streaming di vari tipi di input e output:
- Inviare e ricevere messaggi
- Inviare e ricevere audio
- Inviare audio e ricevere testo
- Inviare testo e ricevere audio
Genera testo in streaming dall'input di testo in streaming
Prima di provare questo esempio, completa la sezione
Prima di iniziare di questa guida
per configurare il progetto e l'app. In questa sezione, fai clic anche su un pulsante per il provider Gemini API che hai scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina. |
Puoi inviare input di testo in streaming e ricevere output di testo in streaming. Assicurati di
creare un'istanza liveModel
e impostare la
modalità di risposta
su Text
.
Swift
L'Live API non è ancora supportato per le app della piattaforma Apple, ma ricontrolla a breve.
Kotlin
// Initialize the Vertex AI Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
val model = Firebase.ai(backend = GenerativeBackend.vertexAI(location = "us-central1")).liveModel(
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 Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.vertexAI("us-central1")).liveModel(
"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
L'Live API non è ancora supportato per le app web, ma ricontrolla a breve.
Dart
import 'package:firebase_ai/firebase_ai.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 Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
final model = FirebaseAI.vertexAI(location: 'us-central1').liveModel(
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
}
Unity
using Firebase;
using Firebase.AI;
async Task SendTextReceiveText() {
// Initialize the Vertex AI Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.VertexAI(location: "us-central1")).GetLiveModel(
modelName: "gemini-2.0-flash-live-preview-04-09",
// Configure the model to respond with text
liveGenerationConfig: new LiveGenerationConfig(
responseModalities: new[] { ResponseModality.Text })
);
LiveSession session = await model.ConnectAsync();
// Provide a text prompt
var prompt = ModelContent.Text("tell a short story");
await session.SendAsync(content: prompt, turnComplete: true);
// Receive the response
await foreach (var message in session.ReceiveAsync()) {
// Process the received message
if (!string.IsNullOrEmpty(message.Text)) {
UnityEngine.Debug.Log("Received message: " + message.Text);
}
}
}
Generare audio in streaming dall'input audio in streaming
Prima di provare questo esempio, completa la sezione
Prima di iniziare di questa guida
per configurare il progetto e l'app. In questa sezione, fai clic anche su un pulsante per il provider Gemini API che hai scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina. |
Puoi inviare input audio in streaming e ricevere output audio in streaming. Assicurati
di creare un'istanza LiveModel
e impostare la
modalità di risposta
su Audio
.
Scopri come configurare e personalizzare la voce di risposta (più avanti in questa pagina).
Swift
L'Live API non è ancora supportato per le app della piattaforma Apple, ma ricontrolla a breve.
Kotlin
// Initialize the Vertex AI Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
val model = Firebase.ai(backend = GenerativeBackend.vertexAI(location = "us-central1")).liveModel(
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 Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.vertexAI("us-central1")).liveModel(
"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
L'Live API non è ancora supportato per le app web, ma ricontrolla a breve.
Dart
import 'package:firebase_ai/firebase_ai.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 Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
final model = FirebaseAI.vertexAI(location: 'us-central1').liveModel(
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
}
Unity
using Firebase;
using Firebase.AI;
async Task SendTextReceiveAudio() {
// Initialize the Vertex AI Gemini API backend service
// Set the location to `us-central1` (the flash-live model is only supported in that location)
// Create a `LiveModel` instance with the flash-live model (only model that supports the Live API)
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.VertexAI(location: "us-central1")).GetLiveModel(
modelName: "gemini-2.0-flash-live-preview-04-09",
// Configure the model to respond with audio
liveGenerationConfig: new LiveGenerationConfig(
responseModalities: new[] { ResponseModality.Audio })
);
LiveSession session = await model.ConnectAsync();
// Start a coroutine to send audio from the Microphone
var recordingCoroutine = StartCoroutine(SendAudio(session));
// Start receiving the response
await ReceiveAudio(session);
}
IEnumerator SendAudio(LiveSession liveSession) {
string microphoneDeviceName = null;
int recordingFrequency = 16000;
int recordingBufferSeconds = 2;
var recordingClip = Microphone.Start(microphoneDeviceName, true,
recordingBufferSeconds, recordingFrequency);
int lastSamplePosition = 0;
while (true) {
if (!Microphone.IsRecording(microphoneDeviceName)) {
yield break;
}
int currentSamplePosition = Microphone.GetPosition(microphoneDeviceName);
if (currentSamplePosition != lastSamplePosition) {
// The Microphone uses a circular buffer, so we need to check if the
// current position wrapped around to the beginning, and handle it
// accordingly.
int sampleCount;
if (currentSamplePosition > lastSamplePosition) {
sampleCount = currentSamplePosition - lastSamplePosition;
} else {
sampleCount = recordingClip.samples - lastSamplePosition + currentSamplePosition;
}
if (sampleCount > 0) {
// Get the audio chunk
float[] samples = new float[sampleCount];
recordingClip.GetData(samples, lastSamplePosition);
// Send the data, discarding the resulting Task to avoid the warning
_ = liveSession.SendAudioAsync(samples);
lastSamplePosition = currentSamplePosition;
}
}
// Wait for a short delay before reading the next sample from the Microphone
const float MicrophoneReadDelay = 0.5f;
yield return new WaitForSeconds(MicrophoneReadDelay);
}
}
Queue audioBuffer = new();
async Task ReceiveAudio(LiveSession liveSession) {
int sampleRate = 24000;
int channelCount = 1;
// Create a looping AudioClip to fill with the received audio data
int bufferSamples = (int)(sampleRate * channelCount);
AudioClip clip = AudioClip.Create("StreamingPCM", bufferSamples, channelCount,
sampleRate, true, OnAudioRead);
// Attach the clip to an AudioSource and start playing it
AudioSource audioSource = GetComponent();
audioSource.clip = clip;
audioSource.loop = true;
audioSource.Play();
// Start receiving the response
await foreach (var message in liveSession.ReceiveAsync()) {
// Process the received message
foreach (float[] pcmData in message.AudioAsFloat) {
lock (audioBuffer) {
foreach (float sample in pcmData) {
audioBuffer.Enqueue(sample);
}
}
}
}
}
// This method is called by the AudioClip to load audio data.
private void OnAudioRead(float[] data) {
int samplesToProvide = data.Length;
int samplesProvided = 0;
lock(audioBuffer) {
while (samplesProvided < samplesToProvide && audioBuffer.Count > 0) {
data[samplesProvided] = audioBuffer.Dequeue();
samplesProvided++;
}
}
while (samplesProvided < samplesToProvide) {
data[samplesProvided] = 0.0f;
samplesProvided++;
}
}
Creare esperienze più coinvolgenti e interattive
Questa sezione descrive come creare e gestire funzionalità più coinvolgenti o interattive del Live API.
Modificare la voce della risposta
Live API utilizza Chirp 3 per supportare le risposte di sintesi vocale. Quando utilizzi Firebase AI Logic, puoi inviare audio in una serie di lingue con voci in HD. Per un elenco completo e demo di come suona ogni voce, vedi Chirp 3: voci in HD.
Per specificare una voce, imposta il nome della voce all'interno dell'oggetto speechConfig
come parte
della
configurazione del modello.
Se non specifichi una voce, il valore predefinito è Puck
.
Swift
L'Live API non è ancora supportato per le app della piattaforma Apple, ma ricontrolla a breve.
Kotlin
// ...
val model = Firebase.ai(backend = GenerativeBackend.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 = FirebaseAI.getInstance(GenerativeBackend.vertexAI()).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
L'Live API non è ancora supportato per le app web, ma ricontrolla a breve.
Dart
// ...
final model = FirebaseAI.vertexAI().liveGenerativeModel(
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(voiceName: 'Fenrir'),
),
);
// ...
Unity
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.VertexAI()).GetLiveModel(
modelName: "gemini-2.0-flash-live-preview-04-09",
liveGenerationConfig: new LiveGenerationConfig(
responseModalities: new[] { ResponseModality.Audio },
speechConfig: SpeechConfig.UsePrebuiltVoice("Fenrir"),
);
Per ottenere risultati ottimali quando richiedi al modello di rispondere in una lingua diversa dall'inglese, includi quanto segue nelle istruzioni di sistema:
RESPOND IN LANGUAGE. YOU MUST RESPOND UNMISTAKABLY IN LANGUAGE.
Mantenere il contesto tra sessioni e richieste
Puoi utilizzare una struttura di chat per mantenere il contesto tra sessioni e richieste. Tieni presente che questa opzione funziona solo per l'input e l'output di testo.
Questo approccio è ideale per contesti brevi; puoi inviare interazioni passo passo per rappresentare la sequenza esatta di eventi . Per contesti più lunghi, ti consigliamo di fornire un riepilogo di un singolo messaggio per liberare la finestra di contesto per le interazioni successive.
Gestire le interruzioni
Firebase AI Logic non supporta ancora la gestione delle interruzioni. Ricontrolla presto.
Utilizzare la chiamata di funzioni (strumenti)
Puoi definire strumenti, come le funzioni disponibili, da utilizzare con l'API Live proprio come puoi fare con i metodi standard di generazione di contenuti. Questa sezione descrive alcune sfumature dell'utilizzo dell'API Live con la chiamata di funzioni. Per una descrizione completa ed esempi per la chiamata di funzioni, consulta la guida alla chiamata di funzioni.
Da un singolo prompt, il modello può generare più chiamate di funzione e il codice necessario per concatenare i relativi output. Questo codice viene eseguito in un ambiente
sandbox, generando messaggi
BidiGenerateContentToolCall
successivi. L'esecuzione viene sospesa finché non sono disponibili i risultati di ogni chiamata di funzione, il che garantisce l'elaborazione sequenziale.
Inoltre, l'utilizzo dell'API Live con la chiamata di funzioni è particolarmente efficace perché il modello può richiedere all'utente informazioni di follow-up o chiarimenti. Ad esempio, se il modello non dispone di informazioni sufficienti per fornire un valore di parametro a una funzione che vuole chiamare, può chiedere all'utente di fornire informazioni aggiuntive o chiarimenti.
Il cliente deve rispondere con
BidiGenerateContentToolResponse
.
Limitazioni e requisiti
Tieni presente le seguenti limitazioni e requisiti del Live API.
Trascrizione
Firebase AI Logic non supporta ancora le trascrizioni. Ricontrolla presto.
Lingue
- Lingue di input:consulta l'elenco completo delle lingue di input supportate per i modelli Gemini
- Lingue di output: consulta l'elenco completo delle lingue di output disponibili in Chirp 3: voci in HD
Formati audio
Live API supporta i seguenti formati audio:
- Formato audio di input:audio PCM non elaborato a 16 bit a 16 kHz little-endian
- Formato audio di output:audio PCM a 16 bit non elaborato a 24 kHz little-endian
Limiti di frequenza
Si applicano i seguenti limiti di frequenza:
- 10 sessioni simultanee per progetto Firebase
- 4 milioni di token al minuto
Lunghezza della sessione
La durata predefinita di una sessione è 30 minuti. Quando la durata della sessione supera il limite, la connessione viene interrotta.
Il modello è limitato anche dalle dimensioni del contesto. L'invio di grandi blocchi di input potrebbe comportare la chiusura anticipata della sessione.
Rilevamento dell'attività vocale (VAD)
Il modello esegue automaticamente il rilevamento dell'attività vocale (VAD) su un flusso di input audio continuo. Il rilevamento dell'attività vocale è attivo per impostazione predefinita.
Conteggio dei token
Non puoi utilizzare l'API CountTokens
con Live API.
Fornisci un feedback sulla tua esperienza con Firebase AI Logic