Puoi utilizzare un modello TTS Gemini (gemini-3.8-flash-tts o
gemini-3.8-flash-lite-tts) per sintetizzare un parlato (audio) naturale ed espressivo
dal testo. Quando utilizzi Firebase AI Logic, puoi effettuare questa richiesta direttamente dalla tua app mobile o app web (ad esempio l'app Apple (Swift), Android (Kotlin/Java), web (JavaScript), Flutter (Dart) o Unity).
La generazione di sintesi vocale (TTS) è controllabile, il che significa che fornisci il testo esatto da sintetizzare in parlato, guidando al contempo l'erogazione, ad esempio emozioni, ritmo, voci degli speaker e suoni non vocali come risate o sospiri, utilizzando metadati strutturati e tag vocali incorporati. Puoi pensare alla sintesi vocale come all'opposto della trascrizione (da voce a testo).
Con questa funzionalità, puoi creare funzionalità come:
- Storytelling interattivo e audiolibri: narra storie di lunga durata o giochi di ruolo in cui i personaggi cambiano voce, reagiscono l'uno all'altro con segnali di ascolto sovrapposti e adattano la loro espressione emotiva (ad esempio sussurrando in momenti di suspense o ridendo di una battuta).
- Agenti e assistenti vocali a bassa latenza: trasmetti in streaming il parlato sintetizzato non appena il testo arriva da un LLM, mantenendo una persona vocale coerente durante le conversazioni.
- Lettori di contenuti multilingue e tutor linguistici: leggi articoli, ricette o materiale di studio ad alta voce in oltre 130 lingue e accenti regionali o cambia lingua senza problemi all'interno di una singola conversazione.
Questa guida mostra come generare parlato con uno o più relatori, trasmettere in streaming risposte audio, indirizzare la voce con SpeechMetadata e tag incorporati e scegliere tra voci predefinite, della libreria o personalizzate.
Passa al codice per un singolo interlocutore Passa al codice per più interlocutori Passa al codice per lo streaming
Confronto tra TTS e Live API
Sia i modelli text-to-speech (TTS) che i modelli Live API sono modelli di generazione vocale a bassa latenza che possono essere configurati per diverse voci e lingue di risposta. Tuttavia, sono adatti a casi d'uso molto diversi.
La generazione di sintesi vocale (TTS) è un'interazione richiesta-risposta unidirezionale (testo in entrata, audio in uscita). È progettato per scenari che richiedono la recitazione esatta del testo fornito con un controllo granulare su stile e suono, come la narrazione di podcast, audiolibri o la lettura ad alta voce di articoli.
La generazione di Live API supporta lo streaming bidirezionale per conversazioni vocali in tempo reale (input vocale, output vocale). È eccellente in contesti di conversazione dinamici in cui il modello decide il parlato applicabile da restituire. Tieni presente che i modelli Live API più recenti supportano anche l'input di video e immagini.
Prima di iniziare
|
Fai clic sul tuo provider Gemini API per visualizzare i contenuti e il codice specifici del provider in questa pagina. |
Se non l'hai già 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 il provider Gemini API scelto e creare un'istanza GenerativeModel.
Per testare e perfezionare i prompt, ti consigliamo di utilizzare Google AI Studio.
Modelli che supportano questa funzionalità
gemini-3.8-flash-ttsgemini-3.8-flash-lite-tts
Confronto dei modelli TTS
Entrambi i modelli Gemini 3.x TTS hanno lo stesso schema di richiesta e lo stesso formato di prompt. Tuttavia, di seguito sono riportate alcune differenze relative ai casi in cui potresti utilizzare ciascun modello.
| Funzionalità o workload | gemini-3.8-flash-tts |
gemini-3.8-flash-lite-tts |
|---|---|---|
| Punto di forza principale | Fedeltà vocale di livello professionale, sfumature di recitazione e ampia copertura dei dialetti | Throughput elevato, bassa latenza e convenienza |
| Casi d'uso migliori | Audiolibri, narrazione in studio, dialoghi complessi con più relatori, tag di vocalizzazione frequenti, pronuncia difficile, dialetti regionali | Produzione ad alto volume, cascate di agenti vocali in tempo reale, funzionalità UI di lettura ad alta voce, parlato quotidiano con un singolo speaker |
| Lingue supportate | 132 lingue | 103 lingue |
Genera parlato dal testo
Puoi generare parlato da un input di testo con una voce di un singolo speaker o un dialogo tra due speaker, come file WAV completo (generateContent) o come stream audio PCM non elaborato a bassa latenza (generateContentStream).
Genera voce con un singolo interlocutore
|
Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app. In questa sezione, farai anche clic su un pulsante per il provider Gemini API scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina. |
Ecco come generare audio con un singolo speaker:
Nel tuo
GenerationConfig, impostaresponseModalitiessuAUDIOe configura unSpeechConfigcon quanto segue:(Obbligatorio) Un nome o un ID della voce. Può essere una voce predefinita come
Kore, un ID voce della libreria di voci estesa o un IDvoice_.../voicekey_...di una voce personalizzata.(Facoltativo) Un codice lingua BCP-47. Se omesso, il modello rileva automaticamente la lingua.
Crea un
TextPartcon quanto segue:(Obbligatorio) La trascrizione letterale da pronunciare.
(Facoltativo) Un
SpeechMetadatacon una descrizionestyle(ad esempio,"cheerful and friendly").
Chiama
generateContent. Per impostazione predefinita, le richieste unarie restituiscono un file audio WAV (audio/wav) completo (PCM lineare a 16 bit, 24 kHz, mono, con un'intestazione RIFF standard di 44 byte) nelle parti di dati in linea della risposta.
Swift
import FirebaseAILogic
// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Set `responseModalities` to include `.audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
responseModalities: [.audio],
speechConfig: SpeechConfig(voiceName: "Kore", languageCode: "en-US")
)
// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
modelName: "gemini-3.8-flash-tts",
generationConfig: config
)
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
"Have a wonderful day!",
speechMetadata: SpeechMetadata(style: "cheerful and friendly")
)
// Call `generateContent` to generate the speech output.
let response = try await model.generateContent(prompt)
// Extract the WAV audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
let wavData = part.data // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
let mimeType = part.mimeType // for example: "audio/wav"
print("Received audio data with MIME type: \(mimeType)")
// Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
playAudio(data: wavData)
}
Kotlin
Per Kotlin, i metodi in questo SDK sono funzioni di sospensione e devono essere chiamati da un ambito Coroutine.
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
responseModalities = listOf(ResponseModality.AUDIO)
speechConfig = SpeechConfig(
voice = Voice("Kore"),
languageCode = "en-US"
)
}
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "gemini-3.8-flash-tts",
generationConfig = config
)
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
text(
text = "Have a wonderful day!",
speechMetadata = SpeechMetadata(style = "cheerful and friendly")
)
}
// Call `generateContent` to generate the speech output.
val response = model.generateContent(prompt)
// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
val wavData = part.inlineData // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
playAudio(wavData)
}
Java
Per Java, i metodi di streaming in questo SDK restituiscono un tipoPublisher dalla libreria Reactive Streams.
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
.setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
.setSpeechConfig(new SpeechConfig(new Voice("Kore"), "en-US"))
.build();
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
.generativeModel("gemini-3.8-flash-tts", config);
// Use the GenerativeModelFutures Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
.addText("Have a wonderful day!", new SpeechMetadata(null, "cheerful and friendly"))
.build();
Executor executor = Executors.newSingleThreadExecutor();
// Call `generateContent` to generate the speech output.
// Extract the WAV audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
Part part = result.getCandidates().get(0).getContent().getParts().get(0);
if (part instanceof InlineDataPart) {
byte[] wavData = ((InlineDataPart) part).getInlineData(); // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
playAudio(wavData);
}
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
Web
import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";
// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);
// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
responseModalities: [ResponseModality.AUDIO],
speechConfig: {
voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } },
languageCode: "en-US"
}
};
// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
model: "gemini-3.8-flash-tts",
generationConfig
});
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
{
type: "text",
text: "Have a wonderful day!",
speechMetadata: { style: "cheerful and friendly" }
}
];
// Call `generateContent` to generate the speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();
// Extract the WAV audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
const wavBase64 = inlineDataParts[0].inlineData.data; // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Decode base64 to ArrayBuffer
const wavBuffer = Uint8Array.from(atob(wavBase64), c => c.charCodeAt(0)).buffer;
// The response is a complete WAV file, so the Web Audio API can decode and play it directly.
const audioCtx = new AudioContext();
const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
const source = audioCtx.createBufferSource();
source.buffer = audioBuffer;
source.connect(audioCtx.destination);
source.start();
}
Dart
import 'package:firebase_ai/firebase_ai.dart';
// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
responseModalities: [ResponseModalities.audio],
speechConfig: SpeechConfig(voiceName: 'Kore', languageCode: 'en-US'),
);
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
model: 'gemini-3.8-flash-tts',
generationConfig: config,
);
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
TextPart(
'Have a wonderful day!',
speechMetadata: SpeechMetadata(style: 'cheerful and friendly'),
),
]);
// Call `generateContent` to generate the speech output.
final response = await model.generateContent([prompt]);
// Extract the WAV audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
final Uint8List wavData = part.bytes; // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
await playAudio(wavData);
}
Unity
using Firebase.AI;
// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
// Set `responseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name and language code.
var config = new GenerationConfig(
responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
speechConfig: SpeechConfig.UsePrebuiltVoice("Kore", "en-US")
);
// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
modelName: "gemini-3.8-flash-tts",
generationConfig: config
);
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
new ModelContent.TextPart(
"Have a wonderful day!",
new SpeechMetadata(speaker: null, style: "cheerful and friendly")
)
);
// Call `GenerateContentAsync` to generate the speech output.
var response = await model.GenerateContentAsync(prompt);
// Extract the WAV audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
foreach (var part in response.Candidates[0].Content.Parts) {
if (part is ModelContent.InlineDataPart inlineData) {
byte[] wavData = inlineData.Data; // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
PlayAudio(wavData);
}
}
}
Genera voce con più relatori
|
Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app. In questa sezione, farai anche clic su un pulsante per il provider Gemini API scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina. |
Puoi generare una conversazione naturale tra due persone in un'unica richiesta assegnando a ogni persona una voce distinta e passando ogni riga di dialogo come TextPart:
Crea un
MultiSpeakerVoiceConfigche mappa due nomi di speaker (ad esempio,"Joe"e"Jane") alle loroSpeakerVoiceConfigvoci.Nel tuo
GenerationConfig, impostaresponseModalitiessuAUDIOe passa il tuoMultiSpeakerVoiceConfig(e l'elemento facoltativolanguageCode) inSpeechConfig.Fornisci un array o un elenco di oggetti
TextPart, in particolare unTextPartper turno di dialogo. Su ogniTextPart, impostaSpeechMetadatacon quanto segue:- (Obbligatorio) Un
speakerche corrisponde a uno dei nomi degli speaker definiti nelMultiSpeakerVoiceConfig. - (Facoltativo) Una descrizione di
style(ad esempio,"cheerful and friendly").
- (Obbligatorio) Un
Chiama
generateContent. Il modello sintetizza l'intera conversazione e restituisce un file audio WAV (audio/wav) completo.
Swift
import FirebaseAILogic
// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
let multiSpeechConfig = SpeechConfig(
multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
speakerVoiceConfigs: [
SpeakerVoiceConfig(speaker: "Joe", voiceName: "Puck"),
SpeakerVoiceConfig(speaker: "Jane", voiceName: "Kore")
]
),
languageCode: "en-US"
)
// Set `responseModalities` to include `.audio`.
let config = GenerationConfig(
responseModalities: [.audio],
speechConfig: multiSpeechConfig
)
// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
modelName: "gemini-3.8-flash-tts",
generationConfig: config
)
// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
let prompt: [any PartsRepresentable] = [
TextPart(
"How's it going today, Jane?",
speechMetadata: SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
),
TextPart(
"Not too bad, how about you?",
speechMetadata: SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
)
]
// Call `generateContent` to generate the multi-speaker speech output.
let response = try await model.generateContent(prompt)
// Extract the WAV audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
let wavData = part.data // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
let mimeType = part.mimeType // for example: "audio/wav"
print("Received audio data with MIME type: \(mimeType)")
// Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
playAudio(data: wavData)
}
Kotlin
Per Kotlin, i metodi in questo SDK sono funzioni di sospensione e devono essere chiamati da un ambito Coroutine.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
val multiSpeechConfig = SpeechConfig(
multiSpeakerVoiceConfig = MultiSpeakerVoiceConfig(
speakerVoiceConfigs = listOf(
SpeakerVoiceConfig(speaker = "Joe", voice = Voice("Puck")),
SpeakerVoiceConfig(speaker = "Jane", voice = Voice("Kore"))
)
),
languageCode = "en-US"
)
// Set `responseModalities` to include `AUDIO`.
val config = generationConfig {
responseModalities = listOf(ResponseModality.AUDIO)
speechConfig = multiSpeechConfig
}
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "gemini-3.8-flash-tts",
generationConfig = config
)
// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
val prompt = content {
text(
text = "How's it going today, Jane?",
speechMetadata = SpeechMetadata(speaker = "Joe", style = "cheerful and friendly")
)
text(
text = "Not too bad, how about you?",
speechMetadata = SpeechMetadata(speaker = "Jane", style = "calm and relaxed")
)
}
// Call `generateContent` to generate the multi-speaker speech output.
val response = model.generateContent(prompt)
// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
val wavData = part.inlineData // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
playAudio(wavData)
}
Java
Per Java, i metodi di streaming in questo SDK restituiscono un tipoPublisher dalla libreria Reactive Streams.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
MultiSpeakerVoiceConfig multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
Arrays.asList(
new SpeakerVoiceConfig("Joe", new Voice("Puck")),
new SpeakerVoiceConfig("Jane", new Voice("Kore"))
)
);
SpeechConfig multiSpeechConfig = new SpeechConfig(multiSpeakerVoiceConfig, "en-US");
// Set `responseModalities` to include `AUDIO`.
GenerationConfig config = new GenerationConfig.Builder()
.setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
.setSpeechConfig(multiSpeechConfig)
.build();
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
.generativeModel("gemini-3.8-flash-tts", config);
// Use the `GenerativeModelFutures` Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
Content content = new Content.Builder()
.addText(
"How's it going today, Jane?",
new SpeechMetadata("Joe", "cheerful and friendly"))
.addText(
"Not too bad, how about you?",
new SpeechMetadata("Jane", "calm and relaxed"))
.build();
Executor executor = Executors.newSingleThreadExecutor();
// Call `generateContent` to generate the multi-speaker speech output.
// Extract the WAV audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
Part part = result.getCandidates().get(0).getContent().getParts().get(0);
if (part instanceof InlineDataPart) {
byte[] wavData = ((InlineDataPart) part).getInlineData(); // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
playAudio(wavData);
}
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
Web
import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";
// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);
// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
const generationConfig = {
responseModalities: [ResponseModality.AUDIO],
speechConfig: {
multiSpeakerVoiceConfig: {
speakerVoiceConfigs: [
{ speaker: "Joe", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Puck" } } },
{ speaker: "Jane", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
]
},
languageCode: "en-US"
}
};
// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
model: "gemini-3.8-flash-tts",
generationConfig
});
// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `speechMetadata`.
const prompt = [
{
type: "text",
text: "How's it going today, Jane?",
speechMetadata: { speaker: "Joe", style: "cheerful and friendly" }
},
{
type: "text",
text: "Not too bad, how about you?",
speechMetadata: { speaker: "Jane", style: "calm and relaxed" }
}
];
// Call `generateContent` to generate the multi-speaker speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();
// Extract the WAV audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
const wavBase64 = inlineDataParts[0].inlineData.data; // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Decode base64 to ArrayBuffer
const wavBuffer = Uint8Array.from(atob(wavBase64), c => c.charCodeAt(0)).buffer;
// The response is a complete WAV file, so the Web Audio API can decode and play it directly.
const audioCtx = new AudioContext();
const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
const source = audioCtx.createBufferSource();
source.buffer = audioBuffer;
source.connect(audioCtx.destination);
source.start();
}
Dart
import 'package:firebase_ai/firebase_ai.dart';
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
final multiSpeechConfig = SpeechConfig.multiSpeaker(
multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
speakerVoiceConfigs: [
SpeakerVoiceConfig(speaker: 'Joe', voiceName: 'Puck'),
SpeakerVoiceConfig(speaker: 'Jane', voiceName: 'Kore'),
],
),
languageCode: 'en-US',
);
// Set `responseModalities` to include `audio`.
final config = GenerationConfig(
responseModalities: [ResponseModalities.audio],
speechConfig: multiSpeechConfig,
);
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
model: 'gemini-3.8-flash-tts',
generationConfig: config,
);
// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
final prompt = Content.multi([
TextPart(
"How's it going today, Jane?",
speechMetadata: SpeechMetadata(speaker: 'Joe', style: 'cheerful and friendly'),
),
TextPart(
'Not too bad, how about you?',
speechMetadata: SpeechMetadata(speaker: 'Jane', style: 'calm and relaxed'),
),
]);
// Call `generateContent` to generate the multi-speaker speech output.
final response = await model.generateContent([prompt]);
// Extract the WAV audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
final Uint8List wavData = part.bytes; // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
await playAudio(wavData);
}
Unity
using Firebase.AI;
// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
var multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
new System.Collections.Generic.List<SpeakerVoiceConfig> {
SpeakerVoiceConfig.UsePrebuiltVoice("Joe", "Puck"),
SpeakerVoiceConfig.UsePrebuiltVoice("Jane", "Kore")
}
);
var multiSpeechConfig = SpeechConfig.UseMultiSpeakerVoice(multiSpeakerVoiceConfig, "en-US");
// Set `responseModalities` to include `Audio`.
var config = new GenerationConfig(
responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
speechConfig: multiSpeechConfig
);
// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
modelName: "gemini-3.8-flash-tts",
generationConfig: config
);
// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
var prompt = new ModelContent(
new ModelContent.TextPart(
"How's it going today, Jane?",
new SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
),
new ModelContent.TextPart(
"Not too bad, how about you?",
new SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
)
);
// Call `GenerateContentAsync` to generate the multi-speaker speech output.
var response = await model.GenerateContentAsync(prompt);
// Extract the WAV audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
foreach (var part in response.Candidates[0].Content.Parts) {
if (part is ModelContent.InlineDataPart inlineData) {
byte[] wavData = inlineData.Data; // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
PlayAudio(wavData);
}
}
}
Visualizza la risposta in modo dinamico
|
Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app. In questa sezione, farai anche clic su un pulsante per il provider Gemini API scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina. |
Per un tempo di risposta più breve (TTFA) e una riproduzione in tempo reale, puoi riprodurre in streaming la risposta audio man mano che viene generata, anziché attendere il completamento dell'intero clip. Lo streaming funziona con configurazioni sia con speaker singolo sia con più speaker.
Per trasmettere l'audio in streaming, chiama generateContentStream anziché generateContent.
A differenza delle richieste unarie (che restituiscono un file WAV), le richieste di streaming restituiscono chunk PCM non elaborati a 16 bit con segno little-endian senza intestazione (audio/l16, 24 kHz, mono), in modo da poter aggiungere ogni chunk direttamente al buffer di output audio.
Swift
import FirebaseAILogic
// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Set `responseModalities` to include `.audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
responseModalities: [.audio],
speechConfig: SpeechConfig(voiceName: "Kore")
)
// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
modelName: "gemini-3.8-flash-tts",
generationConfig: config
)
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
"Tell me a story about a brave knight.",
speechMetadata: SpeechMetadata(style: "warm, engaging audiobook narrator")
)
// Call `generateContentStream` to stream the speech output as it is generated.
let responseStream = try model.generateContentStream(prompt)
// Extract the raw PCM audio chunks and queue them for playback:
for try await chunk in responseStream {
for part in chunk.inlineDataParts {
let pcmChunk = part.data // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
// Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
appendAudioChunk(pcmChunk)
}
}
Kotlin
Per Kotlin, i metodi in questo SDK sono funzioni di sospensione e devono essere chiamati da un ambito Coroutine.
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
responseModalities = listOf(ResponseModality.AUDIO)
speechConfig = SpeechConfig(voice = Voice("Kore"))
}
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "gemini-3.8-flash-tts",
generationConfig = config
)
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
text(
text = "Tell me a story about a brave knight.",
speechMetadata = SpeechMetadata(style = "warm, engaging audiobook narrator")
)
}
// Call `generateContentStream` to stream the speech output as it is generated.
// Extract the raw PCM audio chunks and queue them for playback.
model.generateContentStream(prompt).collect { chunk ->
val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
val pcmChunk = part.inlineData // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
// Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
appendAudioChunk(pcmChunk)
}
}
Java
Per Java, i metodi di streaming in questo SDK restituiscono un tipoPublisher dalla libreria Reactive Streams.
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
.setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
.setSpeechConfig(new SpeechConfig(new Voice("Kore")))
.build();
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
.generativeModel("gemini-3.8-flash-tts", config);
// Use the `GenerativeModelFutures` Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
.addText(
"Tell me a story about a brave knight.",
new SpeechMetadata(null, "warm, engaging audiobook narrator"))
.build();
// Call `generateContentStream` to stream the speech output as it is generated.
Publisher<GenerateContentResponse> streamingResponse =
model.generateContentStream(content);
// Extract the raw PCM audio chunks and queue them for playback.
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
@Override
public void onSubscribe(Subscription s) {
s.request(Long.MAX_VALUE);
}
@Override
public void onNext(GenerateContentResponse chunk) {
Part part = chunk.getCandidates().get(0).getContent().getParts().get(0);
if (part instanceof InlineDataPart) {
byte[] pcmChunk = ((InlineDataPart) part).getInlineData(); // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
// Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
appendAudioChunk(pcmChunk);
}
}
@Override
public void onComplete() {
// Audio stream complete.
}
@Override
public void onError(Throwable t) {
t.printStackTrace();
}
});
Web
import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";
// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);
// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
responseModalities: [ResponseModality.AUDIO],
speechConfig: {
voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } }
}
};
// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
model: "gemini-3.8-flash-tts",
generationConfig
});
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
{
type: "text",
text: "Tell me a story about a brave knight.",
speechMetadata: { style: "warm, engaging audiobook narrator" }
}
];
// Call `generateContentStream` to stream the speech output as it is generated.
const result = await model.generateContentStream(prompt);
// Extract the raw PCM audio chunks and queue them for playback:
const playbackQueue = [];
for await (const chunk of result.stream) {
const inlineDataParts = chunk.inlineDataParts();
if (inlineDataParts?.[0]) {
const pcmBase64 = inlineDataParts[0].inlineData.data; // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;
// Append the audio chunk to your audio queue/buffer for playback.
// In a real app, start playing chunks as they arrive (rather than waiting for
// the whole stream to finish) to get the low-latency benefit of streaming.
playbackQueue.push(pcmBuffer);
}
}
// To play back an array of PCM buffers in sequence, pass them to your playback helper (which you'll need to write).
processPlaybackQueue(playbackQueue);
Dart
import 'package:firebase_ai/firebase_ai.dart';
// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
responseModalities: [ResponseModalities.audio],
speechConfig: SpeechConfig(voiceName: 'Kore'),
);
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
model: 'gemini-3.8-flash-tts',
generationConfig: config,
);
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
TextPart(
'Tell me a story about a brave knight.',
speechMetadata: SpeechMetadata(style: 'warm, engaging audiobook narrator'),
),
]);
// Call `generateContentStream` to stream the speech output as it is generated.
final responseStream = model.generateContentStream([prompt]);
// Extract the raw PCM audio chunks and queue them for playback:
await for (final chunk in responseStream) {
final part = chunk.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
final Uint8List pcmChunk = part.bytes; // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
// Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
appendAudioChunk(pcmChunk);
}
}
Unity
using System.Collections.Generic;
using System.Linq;
using Firebase.AI;
// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
// Set `ResponseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
var config = new GenerationConfig(
responseModalities: new List<ResponseModality> { ResponseModality.Audio },
speechConfig: SpeechConfig.UsePrebuiltVoice("Kore")
);
// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
modelName: "gemini-3.8-flash-tts",
generationConfig: config
);
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
new ModelContent.TextPart(
"Tell me a story about a brave knight.",
new SpeechMetadata(speaker: null, style: "warm, engaging audiobook narrator")
)
);
// Call `GenerateContentStreamAsync` to stream the speech output as it is generated.
var responseStream = model.GenerateContentStreamAsync(prompt);
// Extract the raw PCM audio chunks and queue them for playback:
await foreach (var response in responseStream)
{
var audioParts = response.Candidates.FirstOrDefault().Content.Parts
.OfType<ModelContent.InlineDataPart>();
foreach (var part in audioParts)
{
byte[] pcmChunk = part.Data; // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
// Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
AppendAudioChunk(pcmChunk);
}
}
Controlla la sintesi vocale con metadati e tag incorporati
I modelli Gemini 3.x TTS trattano il text all'interno di ogni TextPart rigorosamente come una trascrizione letterale da leggere ad alta voce. Non scrivere
istruzioni narrative (come "Say cheerfully:") all'interno della stringa di testo, altrimenti
il modello potrebbe leggere queste parole ad alta voce.
Puoi dirigere l'interpretazione vocale utilizzando le seguenti tecniche:
Tag vocali style a livello di turno e incorporati
Suddividi le istruzioni per l'esecuzione in base all'ambito tra SpeechMetadata e i tag tra parentesi angolari in linea (<...>).
| Ambito | Posizionamento | Cosa controlla | Esempi |
|---|---|---|---|
|
A livello di curva (sostenuta per l'intera curva) |
SpeechMetadata.style
|
Emozione, persona, tono, inflessione, tono e velocità di pronuncia complessiva |
"cheerful and friendly","whispered, nervous","speaking rapidly","out of breath","sarcastic"
|
|
Point-in-time (localizzato in un momento specifico della frase) |
In linea nel testo TextPart utilizzando <...>
|
Suoni vocali umani non vocali, respiri, pause o cambiamenti momentanei nell'intonazione |
"Wait... <short pause> did you hear that? <gasp> Someone's at the door."
|
Ritmo, pause, tono ed enfasi
Punteggiatura e puntini di sospensione: utilizza virgole, trattini (
--) e puntini di sospensione (...) nella trascrizione per creare un fraseggio e un'esitazione naturali.Tag di pausa espliciti: inserisci
<short pause>o<long pause>in linea nel punto esatto in cui lo speaker deve fare una pausa:Hold on, let me think... <short pause> Alright, I've got it.Velocità di pronuncia e tono: imposta
styleinSpeechMetadataper controllare il ritmo, il tono o l'inflessione generali della battuta (ad esempio,"speaking rapidly and excitedly","speaking slowly"o"monotone and flat"). Se l'emozione o il ritmo cambiano a metà monologo, dividi lo script in battuteTextPartseparate, ciascuna con il propriostyle.Enfasi parola: scrivi parole specifiche nella trascrizione con la prima lettera maiuscola per enfatizzarle:
It was a VERY long day <sigh> ... nobody listens anymore.
Espressioni vocali e suoni non vocali
Inserisci vocalizzazioni umane non vocali in linea utilizzando le parentesi angolari (<...>)
in corrispondenza del confine esatto della parola in cui deve verificarsi il suono. Utilizza vocalizzazioni umane anziché effetti sonori non vocali. Ecco i tag consigliati da utilizzare:
<argh> |
<exhales> |
<heavy breath> |
<scream> |
<snort> |
<breath> |
<gasp> |
<hiss> |
<short pause> |
<sob> |
<cackle> |
<giggle> |
<laugh> /<laughter> |
<shout> |
<throat-clearing> |
<cheer> |
<groan> |
<long pause> |
<shriek> |
<tsk> |
<chuckle> /<chuckles> |
<growl> |
<moan> |
<sigh> /<sighs> |
<whimper> |
<cough> |
<grr> |
<pant> |
<sneeze> |
<whispers> /<whispering> |
<cry> |
<grunt> |
<pff> /<phew> |
<snicker> |
<yawn> |
Interiezioni e voci sovrapposte
Nel dialogo con più interlocutori, puoi racchiudere le brevi reazioni dell'ascoltatore tra caratteri pipe (|reaction|) all'interno della trascrizione dell'interlocutore attivo. L'interlocutore non attivo interviene naturalmente in quel momento senza
richiedere un turno separato:
Brevi segnali di ascolto:
- Turno 1 (
speaker: "Joe"):"So the launch is Thursday |oh hmm| Are we actually ready?" - Turno 2 (
speaker: "Jane"):"Ready enough |oh really?| The last blocker cleared this morning."
- Turno 1 (
Discorso sovrapposto: puoi utilizzare più segmenti di pipe per simulare un discorso simultaneo (funziona meglio con
gemini-3.8-flash-tts), ad esempio:- Turno 1 (
speaker: "Joe"):"Let's surprise him on three |ok| ready?" - Turno 2 (
speaker: "Jane"):"one. two. three. |happy| happy |birthday| birthday!"
- Turno 1 (
Best practice per la coerenza
Esegui prima un test senza
style, poi aggiungi modifiche concise astyle: la maggior parte delle richieste suona naturale con un campostylevuoto. Aggiungi una breve frasestyle(come"casual, friendly"o"reflective and awe-inspired") solo quando un turno richiede un aggiustamento specifico della consegna e riutilizza la stessa breve stringa nei turni quando vuoi una base di riferimento coerente.Scrivi trascrizioni naturali del parlato: includi contrazioni colloquiali e disfluenze naturali (come
"Oh, uh, yeah I think... hm, that's interesting") direttamente nel testo della trascrizione.Evita blocchi
[Audio Profile]e meta-istruzioni legacy: paragrafi lunghi sulla persona, blocchi[Director's Notes]o meta-istruzioni come"maintain identical timbre"aumentano la deviazione della voce. Scegli invece una voce corrispondente dalla Raccolta di voci estesa o crea una voce persistente per il personaggio con Voice Design.Non provare a eseguire l'override dei tratti vocali immutabili in
style: evita di utilizzareSpeechMetadata.styleper modificare l'età, il genere o l'accento permanente di una voce. Seleziona o progetta invece una voce con queste caratteristiche.
Voci supportate
I modelli Gemini 3.x TTS supportano tre modi per specificare una voce:
Tutte le voci sono multilingue, il che significa che puoi utilizzare la stessa voce per generare il parlato in una qualsiasi delle lingue supportate, mantenendo un'identità di chi parla coerente. Ad esempio, se imposti la voce predefinita Kore e invii prompt in spagnolo, hindi e vietnamita, le risposte utilizzano tutte la voce Kore in ciascuna di queste lingue. Sebbene le 30 voci predefinite principali siano voci multilingue per uso generico, le voci della libreria di voci estesa e le voci personalizzate sono ancorate a un'impostazione internazionale o a un accento regionale principale. Ciò significa che possono comunque parlare altre lingue, ma suonano più autentiche nella loro lingua principale.
Voci predefinite principali
I modelli TTS Gemini supportano 30 voci predefinite di base (come Kore,
Puck, Zephyr, Charon e Fenrir), ognuna con caratteristiche vocali
distinte. Passa il nome della voce in SpeechConfig (come mostrato negli esempi di singolo speaker e più speaker riportati in precedenza in questa pagina).
Voci preimpostate dalla libreria di voci estesa
Oltre alle 30 voci predefinite, la libreria di voci estesa offre più di 2000 voci preimpostate selezionate che coprono diverse lingue, accenti regionali, fasce d'età, personaggi e casi d'uso (come audiolibri, agenti di assistenza clienti e lettori di notizie).
Ecco come utilizzare qualsiasi voce della Libreria di voci estesa nella tua app:
Sfoglia e visualizza l'anteprima delle voci utilizzando una di queste opzioni:
Utilizza Google AI Studio o Agent Studio per ottenere la voce
id.Esegui una query sul metodo
listdell'API Voices (ListVoicescontype=prebuilte una querysearchfacoltativa) per ottenere la voceid. Scopri di più nella documentazione di Gemini Developer API o nella documentazione di Agent Platform Gemini API (formerly Vertex AI).
Passa la stringa
iddella voce della libreria come nome della voce inSpeechConfig(simile a quanto mostrato nell'esempio di singolo speaker precedente in questa pagina).
Voci personalizzate: progettazione e replica vocale
I modelli Gemini 3.x TTS supportano anche le voci personalizzate utilizzando una delle seguenti opzioni:
Voice Design (anteprima): genera una voce personalizzata unica da una descrizione in linguaggio naturale dell'età, del timbro vocale, dell'accento e della personalità di chi parla (senza bisogno di audio di riferimento). Restituisce un ID voce memorizzato (
voice_...).Replica vocale (anteprima): replica la voce, il tono e la cadenza di un oratore da una registrazione di riferimento e da una registrazione del consenso vocale. Restituisce un ID voce archiviato nel progetto (
voice_...) o una chiave di replica vocale stateless gestita dall'app (voicekey_...).
Utilizza una voce personalizzata nell'app Firebase AI Logic
La creazione e la gestione di voci personalizzate è un'operazione amministrativa o lato server, pertanto gli SDK client Firebase AI Logic non espongono direttamente gli endpoint di gestione delle voci (CreateVoice, ListVoices, DeleteVoice).
Per utilizzare una voce personalizzata, devi invece:
Crea la voce personalizzata una volta utilizzando una di queste opzioni:
Utilizza Google AI Studio o Agent Studio per ottenere l'identificatore
voice_<id>ovoicekey_<id>.Utilizza l'API Voices per ottenere l'identificatore
voice_<id>ovoicekey_<id>. Scopri di più nella documentazione del provider Gemini API che hai scelto:Gemini Developer API: Generazione di parlato
Agent Platform Gemini API (formerly Vertex AI): Voice Design e Replica vocale
Passa la stringa
voice_<id>ovoicekey_<id>come nome della voce inSpeechConfig(simile a quanto mostrato nell'esempio di singolo speaker riportato in precedenza in questa pagina).
Tieni presente i seguenti requisiti quando utilizzi voci personalizzate:
Località (Agent Platform Gemini API (formerly Vertex AI)): le voci personalizzate (
voice_...evoicekey_...) sono supportate solo nella localitàglobal(che è la località predefinita quando utilizzi Firebase AI Logic).Richieste con un solo speaker:
MultiSpeakerVoiceConfigsupporta solo le voci predefinite di base. Per utilizzare voci progettate o replicate personalizzate in un dialogo con più personaggi, sintetizza il turno di ogni personaggio in una richiesta separata con un singolo speaker.Conservazione e scadenza: le voci personalizzate archiviate (
voice_...) scadono se non vengono utilizzate per 1 anno (ogni richiesta di sintesi reimposta il timer di conservazione di 1 anno); le chiavi di replica vocale stateless (voicekey_...) scadono 7 giorni dopo la creazione.
Lingue supportate
I modelli Gemini 3.x TTS rilevano automaticamente la lingua dal testo di input, anche quando un prompt cambia lingua tra i turni di un dialogo con più interlocutori.
- Gemini 3.8 Flash TTS (
gemini-3.8-flash-tts): supporta 132 lingue. - Gemini 3.8 Flash‑Lite TTS (
gemini-3.8-flash-lite-tts): supporta 103 lingue.
(Facoltativo) Imposta esplicitamente un codice lingua
Se vuoi limitare esplicitamente la sintesi vocale a un'impostazione locale specifica, puoi passare un languageCode BCP-47 nel tuo SpeechConfig:
Formati di uscita audio
Il formato audio predefinito restituito in InlineDataPart dipende dal fatto che tu effettui una richiesta unaria o in streaming:
| Metodo di richiesta | Tipo MIME restituito predefinito | Dettagli del formato audio |
|---|---|---|
|
Unario ( generateContent)
|
audio/wav
|
File WAV completo (PCM lineare a 16 bit, 24 kHz, mono, little-endian) con un'intestazione RIFF standard di 44 byte.
Può essere riprodotto direttamente dai lettori audio standard della piattaforma (come
|
|
Streaming ( generateContentStream)
|
audio/l16
|
Chunk PCM non elaborati senza intestazione a 16 bit signed, little endian
a 24 kHz, mono.
Progettato per la coda di buffer a bassa latenza e la concatenazione senza intestazioni di file per chunk. |
Limitazioni e requisiti
Tieni presente le seguenti limitazioni e i seguenti requisiti quando utilizzi i modelli Gemini 3.x TTS:
Input solo di testo, output solo audio: i modelli TTS accettano solo input di testo (
TextPart) e richiedono cheresponseModalitiessia impostato suAUDIO.Solo sintesi letterale: i modelli recitano la trascrizione fornita letteralmente e non generano risposte di testo conversazionali.
Limiti di token: l'input massimo è di 8192 token e l'output massimo è di 16.384 token per richiesta.
Limite di più interlocutori:
MultiSpeakerVoiceConfigrichiede 2 interlocutori e supporta solo le voci predefinite di base. OgniTextPartin una richiesta con più speaker deve includere unSpeechMetadata.speakercorrispondente a uno degli speaker configurati.Parametri e metodi non supportati:
- Gli SDK Firebase AI Logic non supportano ancora l'impostazione di
responseFormatinGenerationConfigper eseguire l'override del formato di output audio predefinito. - L'impostazione
systemInstruction,temperature,topP,topK,candidateCount,presencePenaltyofrequencyPenaltynon è supportata e causa l'errore delle richieste con un errore400 INVALID_ARGUMENT. - La chiamata a
countTokensnon è supportata per i modelli TTS (i conteggi dei token vengono restituiti inusageMetadatanella risposta).
- Gli SDK Firebase AI Logic non supportano ancora l'impostazione di
Località (Agent Platform Gemini API (formerly Vertex AI)): le voci personalizzate (
voice_...evoicekey_...) richiedono la localitàglobal(che è la località predefinita quando utilizzi Firebase AI Logic).
Esegui la migrazione da gemini-3.1-flash-tts-preview
Sia gemini-3.8-flash-tts che gemini-3.8-flash-lite-tts utilizzano la stessa struttura di richiesta. Consulta la tabella di confronto modelli per scegliere il sostituto migliore per il tuo workload e aggiorna il codice come segue:
| Area |
gemini-3.1-flash-tts-preview (Legacy)
|
gemini-3.8-flash-tts egemini-3.8-flash-lite-tts
|
|---|---|---|
| Stile di presentazione e regia |
Incorporati nel testo del prompt. Ad esempio:"Say cheerfully: ...",[Audio Profile],[Director's Notes]
|
Passato in SpeechMetadata(style: "...") su ogni
TextPart
Mantieni il testo |
| Dialogo con più interlocutori |
Singola stringa di testo con prefissi "Speaker: ..." in linea
|
Un TextPart per turno di dialogo, con
SpeechMetadata(speaker: "...", style: "...") su ogni
TextPart
|
| Tag vocali in linea |
Parentesi quadre. Ad esempio,[sigh] o [laughs]
|
Parentesi angolari. Ad esempio,<sigh> o
<laugh> o
<short pause>
Scrivi le disfluenze del parlato come |
Formato audio unario predefinito
(generateContent)
|
PCM non elaborato a 16 bit senza intestazione (audio/pcm, 24 kHz, mono)
|
File WAV completo (audio/wav, PCM a 16 bit, 24 kHz, mono, con un'intestazione RIFF a 44 byte)
Lo streaming ( |
| Istruzioni di sistema, temperatura, top-P, top-K | Ignorato |
Rifiutata con un errore 400 INVALID_ARGUMENT. Rimuovi questi parametri dalla configurazione del modello.
|
Elenco di controllo per la migrazione
Esegui l'upgrade all'ultima versione dell'SDK Firebase AI Logic e aggiorna il nome del modello in
gemini-3.8-flash-ttsogemini-3.8-flash-lite-tts.Sposta le istruzioni di stile in
SpeechMetadata.style: rimuovi i prefissi"Say cheerfully:",[Audio Profile],[Scene]e i blocchi[Director's Notes]dalle stringhe dei prompt in modo che il modello non li legga ad alta voce. Passa invece una descrizione concisa dello stile inSpeechMetadata.style.Suddividi gli script con più interlocutori in turni
TextPartseparati: sostituisci i blocchi di testo"Joe: ... \n Jane: ..."con un array/elenco di oggettiTextPartin cui ogni turno impostaSpeechMetadata.speaker.Converti i tag
[...]in tag<...>: sostituisci i tag audio tra parentesi quadre (come[whispers],[sighs],[laughs]) con i tag vocali tra parentesi angolari (come<whispers>,<sigh>,<laugh>,<short pause>).Aggiorna la riproduzione audio unaria: poiché
generateContentora restituisce un file WAV completo (con un'intestazione RIFF di 44 byte) anziché un PCM non elaborato senza intestazione, rimuovi qualsiasi codice che anteponga manualmente un'intestazione WAV alle risposte unarie (o salta l'intestazione di 44 byte se inserisci campioni PCM non elaborati in un'API buffer di basso livello comeAudioTrackdi Android oAudioClipdi Unity).Rimuovi i parametri di configurazione non supportati: rimuovi
temperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyesystemInstructiondalla configurazione TTSGenerativeModel.
Cos'altro sai fare?
-
Inizia a pensare alla preparazione per la produzione (consulta l'elenco di controllo per la produzione):
- Applica Firebase App Check il prima possibile per proteggere Gemini API da abusi da parte di client non autorizzati.
- Utilizza Firebase Remote Config o template di prompt del server per apportare modifiche on demand alle configurazioni della tua funzionalità di AI (come il nome del modello) senza rilasciare una nuova versione della tua app.
Prova altre funzionalità
- Crea conversazioni a più turni (chat).
- Genera testo da prompt di solo testo.
- Genera output strutturato (come JSON) da prompt di testo e multimodali.
- Genera e modifica immagini da prompt di testo e multimodali.
- Input e output in streaming (incluso l'audio) utilizzando Gemini Live API.
-
Utilizza strumenti (come la chiamata di funzione
e il grounding con
Google Search oGoogle Maps ) per connettere un modello Gemini ad altre parti della tua app e a sistemi e informazioni esterni.
Scopri come controllare la generazione di contenuti
- Scopri di più sulla progettazione dei prompt, tra cui best practice, strategie ed esempi di prompt.
- Configura i parametri del modello, come il numero massimo di token di output, la probabilità di token di output ripetuti e così via.
- Utilizza le impostazioni di sicurezza per regolare la probabilità di ricevere risposte che potrebbero essere considerate dannose.
Scopri di più sui modelli supportati
Scopri di più sui modelli disponibili per vari casi d'uso e sulle relative quote e prezzi.Invia un feedback sulla tua esperienza con Firebase AI Logic