É possível usar um modelo de TTS Gemini (gemini-3.8-flash-tts ou gemini-3.8-flash-lite-tts) para sintetizar uma fala (áudio) natural e expressiva com base em um texto. Ao usar o Firebase AI Logic, é possível fazer essa solicitação diretamente do seu app para dispositivos móveis ou web app (como o app Apple (Swift), Android (Kotlin/Java), Web (JavaScript), Flutter (Dart) ou Unity).
A geração de conversão de texto em voz (TTS) é controlável, o que significa que você fornece o texto exato para sintetizar em fala, enquanto orienta a entrega, como emoção, ritmo, vozes de locutores e sons não verbais, como risadas ou suspiros, usando metadados estruturados e tags vocais inline. A TTS é o oposto da transcrição (conversão de voz em texto).
Com esse recurso, é possível criar recursos como:
- Narrativas interativas e audiolivros: narre histórias longas ou jogos de RPG em que os personagens mudam de voz, reagem uns aos outros com interjeições sobrepostas e adaptam a entrega emocional (como sussurrar em suspense ou rir de uma piada).
- Agentes e assistentes de voz de baixa latência: transmita fala sintetizada assim que o texto chegar de um LLM, mantendo uma voz consistente em todas as interações.
- Leitores de conteúdo multilíngue e tutores de idiomas: leia artigos, receitas ou materiais de estudo em voz alta em mais de 130 idiomas e sotaques regionais ou mude de idioma sem problemas em uma única conversa.
Este guia mostra como gerar falas com um ou vários locutores, transmitir
respostas de áudio, direcionar a entrega vocal com SpeechMetadata e tags inline
e escolher entre vozes predefinidas, de biblioteca ou personalizadas.
Sequência para código de locutor único Sequência para código de vários locutores Sequência para código de streaming
Comparação entre a TTS e o Live API
Os modelos de conversão de texto em voz (TTS) e Live API são modelos de baixa latência que geram fala e podem ser configurados para diferentes vozes e idiomas de resposta. No entanto, eles atendem a casos de uso muito diferentes.
A geração de conversão de texto em voz (TTS) é uma interação unidirecional de solicitação-resposta (entrada de texto, saída de áudio). Ele é personalizado para cenários que exigem recitação exata do texto fornecido com controle detalhado sobre estilo e som, como narração de podcasts, audiolivros ou leitura de artigos em voz alta.
A geração de Live API é compatível com streaming bidirecional para conversas por voz em tempo real (entrada e saída de voz). Ele se destaca em contextos de conversação dinâmicos em que o modelo decide a fala aplicável a ser retornada. Os modelos Live API mais recentes também aceitam entradas de vídeo e imagem.
Antes de começar
|
Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página. |
Se ainda não tiver feito isso, conclua o
guia de iniciação, que descreve como
configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK,
inicializar o serviço de back-end para o provedor Gemini API escolhido e
criar uma instância GenerativeModel.
Para testar e iterar seus comandos, recomendamos usar o Google AI Studio.
Modelos que oferecem suporte a esse recurso
gemini-3.8-flash-ttsgemini-3.8-flash-lite-tts
Comparação de modelos de TTS
Os dois modelos Gemini 3.x TTS têm o mesmo esquema de solicitação e formato de comando. No entanto, confira algumas diferenças para saber quando usar cada modelo.
| Recurso ou carga de trabalho | gemini-3.8-flash-tts |
gemini-3.8-flash-lite-tts |
|---|---|---|
| Principal ponto forte | Fidelidade de voz de nível profissional, nuances de atuação e ampla cobertura de dialetos | Alta capacidade de processamento, baixa latência e eficiência de custos |
| Melhores casos de uso | Audiolivros, narração de estúdio, diálogos complexos com vários falantes, tags frequentes de vocal-burst, pronúncia difícil, dialetos regionais | Produção de alto volume, cascatas de agentes de voz em tempo real, recursos de interface de leitura em voz alta, fala diária de um único locutor |
| Idiomas aceitos | 132 idiomas | 103 idiomas |
Gerar fala com base em texto
É possível gerar fala com base em uma entrada de texto em uma voz de um único locutor ou em um
diálogo de dois locutores, seja como um arquivo WAV completo (generateContent) ou como um
stream de áudio PCM bruto de baixa latência (generateContentStream).
Gerar fala com um único locutor
|
Antes de testar este exemplo, conclua a seção
Antes de começar deste guia
para configurar o projeto e o app. Nessa seção, você também vai clicar em um botão para o provedor do Gemini API escolhido para ver o conteúdo específico do provedor nesta página. |
Veja como gerar áudio com um único locutor:
No
GenerationConfig, definaresponseModalitiescomoAUDIOe configure umSpeechConfigcom o seguinte:(Obrigatório) Um nome ou ID de voz. Pode ser uma voz predefinida, como
Kore, um ID de voz da Biblioteca de vozes estendida ou um ID devoice_.../voicekey_...de voz personalizada.(Opcional) Um código de idioma BCP-47. Se omitido, o modelo detectará o idioma automaticamente.
Crie um
TextPartcom o seguinte:(Obrigatório) A transcrição literal a ser falada.
(Opcional) Um
SpeechMetadatacom uma descriçãostyle(por exemplo,"cheerful and friendly").
Chame
generateContent. Por padrão, as solicitações unárias retornam um arquivo de áudio WAV (audio/wav) completo (PCM linear de 16 bits, 24 kHz, mono, com um cabeçalho RIFF padrão de 44 bytes) nas partes de dados inline da resposta.
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
No Kotlin, os métodos desse SDK são funções de suspensão e precisam ser chamados em um escopo de corrotina.
// 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
Para Java, os métodos de streaming neste SDK retornam um tipoPublisher da biblioteca 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);
}
}
}
Gerar fala com vários locutores
|
Antes de testar este exemplo, conclua a seção
Antes de começar deste guia
para configurar o projeto e o app. Nessa seção, você também vai clicar em um botão para o provedor do Gemini API escolhido para ver o conteúdo específico do provedor nesta página. |
É possível gerar uma conversa natural entre dois falantes em uma única solicitação. Para isso,
atribua uma voz diferente a cada falante e transmita cada linha de diálogo como um
TextPart próprio:
Crie um
MultiSpeakerVoiceConfigque mapeie dois nomes de locutor (por exemplo,"Joe"e"Jane") para as vozesSpeakerVoiceConfigdeles.No
GenerationConfig, definaresponseModalitiescomoAUDIOe transmita oMultiSpeakerVoiceConfig(e olanguageCodeopcional) paraSpeechConfig.Forneça uma matriz ou lista de objetos
TextPart, especificamente umTextPartpor turno de diálogo. Em cadaTextPart, definaSpeechMetadatacom o seguinte:- (Obrigatório) Uma
speakerque corresponde a um dos nomes de alto-falante definidos noMultiSpeakerVoiceConfig. - (Opcional) Uma descrição de
style(por exemplo,"cheerful and friendly").
- (Obrigatório) Uma
Chame
generateContent. O modelo sintetiza a conversa completa e retorna um arquivo de áudio 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
No Kotlin, os métodos desse SDK são funções de suspensão e precisam ser chamados em um escopo de corrotina.
// 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
Para Java, os métodos de streaming neste SDK retornam um tipoPublisher da biblioteca 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);
}
}
}
Mostrar composição da resposta
|
Antes de testar este exemplo, conclua a seção
Antes de começar deste guia
para configurar o projeto e o app. Nessa seção, você também vai clicar em um botão para o provedor do Gemini API escolhido para ver o conteúdo específico do provedor nesta página. |
Para reduzir o tempo até o primeiro áudio (TTFA, na sigla em inglês) e reproduzir em tempo real, é possível transmitir a resposta de áudio conforme ela é gerada, em vez de esperar que o clipe inteiro termine. O streaming funciona com configurações de locutor único e vários locutores.
Para fazer streaming de fala, chame generateContentStream em vez de generateContent.
Ao contrário das solicitações unárias (que retornam um arquivo WAV), as solicitações de streaming retornam
blocos PCM de 16 bits sem cabeçalho (audio/l16, 24 kHz,
mono) para que você possa anexar cada bloco diretamente ao buffer de saída de áudio.
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
No Kotlin, os métodos desse SDK são funções de suspensão e precisam ser chamados em um escopo de corrotina.
// 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
Para Java, os métodos de streaming neste SDK retornam um tipoPublisher da biblioteca 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);
}
}
Controlar a saída de voz com metadados e tags inline
Os modelos Gemini 3.x TTS tratam o text dentro de cada TextPart
estritamente como uma transcrição literal a ser lida em voz alta. Não escreva
instruções narrativas (como "Say cheerfully:") dentro da string de texto, ou
o modelo poderá ler essas palavras em voz alta.
Você pode direcionar a performance vocal usando as seguintes técnicas:
Tags vocais inline e style no nível da fala
Divida as instruções de desempenho por escopo entre SpeechMetadata e
tags de colchetes angulares inline (<...>).
| Escopo | Onde colocar | O que ele controla | Exemplos |
|---|---|---|---|
|
Nível de turno (sustentado durante todo o turno) |
SpeechMetadata.style
|
Emoção, persona, tom, inflexão, tom e ritmo geral da fala |
"cheerful and friendly","whispered, nervous","speaking rapidly","out of breath","sarcastic"
|
|
Pontual (localizado em um momento específico da frase) |
Inline no texto TextPart usando <...>
|
Sons vocais humanos não verbais, respirações, pausas ou mudanças momentâneas na fala |
"Wait... <short pause> did you hear that? <gasp> Someone's at the door."
|
Ritmo, pausas, tom e ênfase
Pontuação e reticências: use vírgulas, travessões (
--) e reticências (...) na transcrição para criar frases e hesitações naturais.Tags de pausa explícitas: insira
<short pause>ou<long pause>inline no ponto exato em que o locutor deve pausar:Hold on, let me think... <short pause> Alright, I've got it.Velocidade e tom da fala: defina
styleemSpeechMetadatapara controlar o ritmo, o tom ou a inflexão geral da fala (por exemplo,"speaking rapidly and excitedly","speaking slowly"ou"monotone and flat"). Se a emoção ou o ritmo mudar no meio do monólogo, divida o script em falasTextPartseparadas, cada uma com o própriostyle.Ênfase em palavras: use letras maiúsculas em palavras específicas da transcrição para enfatizá-las:
It was a VERY long day <sigh> ... nobody listens anymore.
Sons não verbais e explosões vocais
Insira vocalizações humanas não verbais usando colchetes angulares (<...>)
no limite exato da palavra em que o som deve ocorrer. Use vocalizações humanas
em vez de efeitos sonoros não vocais. Confira as tags recomendadas:
<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> |
Sinais de escuta ativa e fala sobreposta
Em diálogos com vários locutores, é possível colocar reações breves do ouvinte
entre caracteres de barra vertical (|reaction|) na transcrição do
locutor ativo. O falante não ativo intervém naturalmente nesse ponto sem
precisar de uma vez separada:
Canal de retorno do ouvinte curto:
- 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 (
Fala sobreposta: é possível usar vários segmentos de barra vertical para simular fala simultânea (funciona melhor com
gemini-3.8-flash-tts), como:- 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 (
Práticas recomendadas para consistência
Teste sem
styleprimeiro e depois adicione ajustes concisos destyle: a maioria das solicitações soa natural com um campostylevazio. Adicione uma frase curtastyle(como"casual, friendly"ou"reflective and awe-inspired") apenas quando uma fala precisar de um ajuste de entrega específico e reutilize essa mesma string curta em várias falas quando quiser uma linha de base consistente.Escreva transcrições de fala natural: inclua contrações de conversação e disfluências naturais (como
"Oh, uh, yeah I think... hm, that's interesting") diretamente no texto da transcrição.Evite blocos
[Audio Profile]legados e metainstruções: parágrafos longos de persona, blocos[Director's Notes]ou metainstruções como"maintain identical timbre"aumentam o desvio de voz. Em vez disso, escolha uma voz correspondente na Biblioteca de vozes estendida ou crie uma voz de personagem persistente com o Design de voz.Não tente substituir características de voz imutáveis em
style: evite usarSpeechMetadata.stylepara mudar a idade, o gênero ou o sotaque permanente de uma voz. Em vez disso, selecione ou crie uma voz com essas características.
Vozes compatíveis
Os modelos Gemini 3.x TTS oferecem três maneiras de especificar uma voz:
Todas as vozes são multilíngues, o que significa que você pode usar a mesma voz para gerar
fala em qualquer um dos idiomas compatíveis, mantendo uma
identidade de locutor consistente. Por exemplo, se você definir a voz como a voz pré-criada
Kore e enviar comandos em espanhol, hindi e vietnamita, as respostas
vão usar a voz Kore em cada um desses idiomas. As
30 vozes principais pré-criadas são multilíngues de uso geral, mas as vozes da biblioteca de vozes estendida e as
vozes personalizadas são ancoradas em uma localidade principal ou sotaque
regional. Isso significa que eles ainda podem falar outros idiomas, mas soam
mais autênticos na localidade principal.
Vozes predefinidas principais
Os modelos de TTS Gemini são compatíveis com 30 vozes pré-criadas principais (como Kore, Puck, Zephyr, Charon e Fenrir), cada uma com características vocais distintas. Transmita o nome da voz em SpeechConfig (conforme mostrado nos exemplos de locutor único e vários locutores anteriormente nesta página).
Vozes predefinidas da Biblioteca de Voz Estendida
Além das 30 vozes predefinidas, a Biblioteca de Vozes Estendida oferece mais de 2.000 vozes predefinidas selecionadas que abrangem diversos idiomas, sotaques regionais, faixas etárias, personas de personagens e casos de uso (como audiolivros, agentes de suporte ao cliente e leitores de notícias).
Veja como usar qualquer voz da Biblioteca de Vozes Estendida no seu app:
Procure e ouça as vozes usando uma destas opções:
Use Google AI Studio ou Agent Studio para receber a voz
id.Consulte o método
listda API Voices (ListVoicescomtype=prebuilte uma consultasearchopcional) para receber a vozid. Saiba mais na documentação do Gemini Developer API ou na documentação do Agent Platform Gemini API (formerly Vertex AI).
Transmita a string
idda voz da biblioteca como o nome da voz emSpeechConfig(semelhante ao que é mostrado no exemplo de locutor único anteriormente nesta página).
Vozes personalizadas: design e replicação de voz
Os modelos Gemini 3.x TTS também são compatíveis com vozes personalizadas usando uma das seguintes opções:
Design de voz (pré-lançamento): gere uma voz personalizada exclusiva com base em uma descrição em linguagem natural da idade, do timbre vocal, do sotaque e da persona de um locutor (sem precisar de áudio de referência). Retorna um ID de voz armazenado (
voice_...).Replicação de voz (pré-lançamento): replique a voz, o tom e a cadência de um locutor usando uma gravação de referência e uma gravação de consentimento falado. Retorna um ID de voz armazenado no projeto (
voice_...) ou uma chave de replicação de voz sem estado gerenciada pelo app (voicekey_...).
Usar uma voz personalizada no app Firebase AI Logic
A criação e o gerenciamento de vozes personalizadas são operações administrativas ou do lado do servidor.
Portanto, os SDKs do cliente do Firebase AI Logic não expõem diretamente os
endpoints de gerenciamento de vozes (CreateVoice, ListVoices, DeleteVoice).
Em vez disso, para usar uma voz personalizada, faça o seguinte:
Crie a voz personalizada uma vez usando uma destas opções:
Use Google AI Studio ou Agent Studio para receber o identificador
voice_<id>ouvoicekey_<id>.Use a API Voices para receber o identificador
voice_<id>ouvoicekey_<id>. Saiba mais na documentação do provedor de Gemini API escolhido:Gemini Developer API: Geração de fala
Agent Platform Gemini API (formerly Vertex AI): Design de voz e Replicação de voz
Transmita a string
voice_<id>ouvoicekey_<id>como o nome da voz emSpeechConfig(semelhante ao que é mostrado no exemplo de locutor único anteriormente nesta página).
Lembre-se dos seguintes requisitos ao usar vozes personalizadas:
Local (Agent Platform Gemini API (formerly Vertex AI)): as vozes personalizadas (
voice_...evoicekey_...) só são compatíveis com o localglobal, que é o local padrão ao usar Firebase AI Logic.Solicitações de um único locutor: o
MultiSpeakerVoiceConfigsó aceita as vozes principais pré-criadas. Para usar vozes personalizadas ou replicadas em um diálogo com vários personagens, sintetize a fala de cada personagem em uma solicitação separada de um único falante.Retenção e validade: as vozes personalizadas armazenadas (
voice_...) expiram se não forem usadas por 1 ano (cada solicitação de síntese redefine o timer de retenção de 1 ano). As chaves de replicação de voz sem estado (voicekey_...) expiram 7 dias após a criação.
Idiomas compatíveis
Os modelos Gemini 3.x TTS detectam automaticamente o idioma do texto de entrada, inclusive quando um comando muda de idioma em um diálogo com vários falantes.
- Gemini 3.8 Flash TTS (
gemini-3.8-flash-tts): oferece suporte a 132 idiomas. - Gemini 3.8 Flash‑Lite TTS (
gemini-3.8-flash-lite-tts): oferece suporte a 103 idiomas.
(Opcional) Definir explicitamente um código de idioma
Se você quiser restringir explicitamente a síntese de voz a uma localidade específica, transmita um languageCode BCP-47 no SpeechConfig:
Formatos de saída de áudio
O formato de áudio padrão retornado em InlineDataPart depende se você
faz uma solicitação unária ou de streaming:
| Método de solicitação | Tipo MIME retornado padrão | Detalhes do formato de áudio |
|---|---|---|
|
Unário ( generateContent)
|
audio/wav
|
Arquivo WAV completo (PCM linear de 16 bits, 24 kHz, mono,
little-endian) com um cabeçalho RIFF padrão de 44 bytes.
Pode ser reproduzido diretamente por players de áudio de plataforma padrão (como
|
|
Streaming ( generateContentStream)
|
audio/l16
|
Fragmentos PCM brutos de 16 bits com sinal little-endian sem cabeçalho
a 24 kHz, mono.
Projetado para fila do buffer de baixa latência e concatenação sem cabeçalhos de arquivo por bloco. |
Limitações e requisitos
Considere as seguintes limitações e requisitos ao usar os modelos Gemini 3.x TTS:
Entrada somente de texto, saída somente de áudio: os modelos de TTS aceitam apenas entrada de texto (
TextPart) e exigem queresponseModalitiesseja definido comoAUDIO.Somente síntese literal: os modelos recitam a transcrição fornecida literalmente e não geram respostas de texto conversacionais.
Limites de tokens: o máximo de entrada é de 8.192 tokens, e o máximo de saída é de 16.384 tokens por solicitação.
Limite de vários locutores: o
MultiSpeakerVoiceConfigrequer dois locutores e aceita apenas vozes pré-criadas principais. CadaTextPartem uma solicitação com vários locutores precisa incluir umSpeechMetadata.speakercorrespondente a um dos locutores configurados.Parâmetros e métodos não aceitos:
- Os SDKs do Firebase AI Logic ainda não permitem definir
responseFormatemGenerationConfigpara substituir o formato de saída de áudio padrão. - Não é possível definir
systemInstruction,temperature,topP,topK,candidateCount,presencePenaltyoufrequencyPenalty, e isso faz com que as solicitações falhem com um erro400 INVALID_ARGUMENT. - Não é possível chamar
countTokenspara os modelos de TTS (as contagens de tokens são retornadas emusageMetadatana resposta).
- Os SDKs do Firebase AI Logic ainda não permitem definir
Local (Agent Platform Gemini API (formerly Vertex AI)): as vozes personalizadas (
voice_...evoicekey_...) exigem o localglobal(que é o local padrão ao usar Firebase AI Logic).
Migrar de
gemini-3.8-flash-tts e gemini-3.8-flash-lite-tts usam a mesma estrutura de solicitação. Consulte a
tabela de comparação de modelos para escolher a melhor
substituição para sua carga de trabalho e atualize o código da seguinte maneira:
| Área |
gemini-3.1-flash-tts-preview (legado)
|
gemini-3.8-flash-tts egemini-3.8-flash-lite-tts
|
|---|---|---|
| Estilo e direção da apresentação |
Incorporado ao texto do comando. Por exemplo:"Say cheerfully: ...",[Audio Profile],[Director's Notes]
|
Transmitido em SpeechMetadata(style: "...") em cada
TextPart
Mantenha o texto de |
| Diálogo com vários locutores |
String de texto única com prefixos "Speaker: ..." inline
|
Um TextPart por turno de diálogo, com
SpeechMetadata(speaker: "...", style: "...") em cada
TextPart
|
| Tags vocais inline |
Colchetes. Por exemplo,[sigh] ou [laughs]
|
Sinal de maior/menor. Por exemplo,<sigh> ou
<laugh> ou
<short pause>
Escreva disfluências faladas, como |
Formato de áudio unário padrão
(generateContent)
|
PCM bruto de 16 bits sem cabeçalho (audio/pcm, 24 kHz, mono)
|
Arquivo WAV completo (audio/wav, PCM de 16 bits,
24 kHz, mono, com um cabeçalho RIFF de 44 bytes)
O streaming
( |
| Instruções do sistema, temperatura, top-P, top-K | Ignorado |
Rejeitado com um erro 400 INVALID_ARGUMENT. Remova esses
parâmetros da configuração do modelo.
|
Lista de verificação de migração
Faça upgrade para a versão mais recente do SDK do Firebase AI Logic e atualize o nome do modelo para
gemini-3.8-flash-ttsougemini-3.8-flash-lite-tts.Mova as instruções de estilo para
SpeechMetadata.style: remova os prefixos"Say cheerfully:",[Audio Profile],[Scene]e os blocos[Director's Notes]das strings de comando para que o modelo não os leia em voz alta. Em vez disso, transmita uma descrição de estilo concisa emSpeechMetadata.style.Divida scripts com vários locutores em turnos
TextPartseparados: substitua os blocos de texto"Joe: ... \n Jane: ..."por uma matriz/lista de objetosTextPartem que cada turno defineSpeechMetadata.speaker.Converter tags
[...]em tags<...>: substitua as tags de áudio entre colchetes (como[whispers],[sighs],[laughs]) por tags vocais entre colchetes angulares (como<whispers>,<sigh>,<laugh>,<short pause>).Atualizar a reprodução de áudio unária: como
generateContentagora retorna um arquivo WAV completo (com um cabeçalho RIFF de 44 bytes) em vez de PCM bruto sem cabeçalho, remova qualquer código que adicione manualmente um cabeçalho WAV a respostas unárias (ou pule o cabeçalho de 44 bytes se estiver alimentando amostras de PCM bruto em uma API de buffer de baixo nível, comoAudioTrackdo Android ouAudioClipdo Unity).Remover parâmetros de configuração não compatíveis: remova
temperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyesystemInstructionda configuraçãoGenerativeModelda TTS.
O que mais você sabe fazer?
-
Comece a pensar na preparação para a produção (consulte a
lista de verificação de produção):
- Aplique o Firebase App Check o quanto antes para ajudar a proteger o Gemini API contra abusos de clientes não autorizados.
- Use Firebase Remote Config ou modelos de comando do servidor para fazer mudanças on demand nas configurações do recurso de IA (como o nome do modelo) sem lançar uma nova versão do app.
Teste outros recursos
- Crie conversas multiturno (chat).
- Gerar texto gerado com base em comandos de texto.
- Gerar saída estruturada (como JSON) com base em comandos de texto e multimodais.
- Gere e edite imagens com comandos de texto e multimodais.
- Entrada e saída de streaming (incluindo áudio) usando o Gemini Live API.
-
Use ferramentas (como chamada de função
e embasamento com
Google Search ouGoogle Maps ) para conectar um modelo Gemini a outras partes do app e a sistemas e informações externos.
Saiba como controlar a geração de conteúdo
- Entenda o design de comandos, incluindo práticas recomendadas, estratégias e exemplos de comandos.
- Configurar parâmetros do modelo, como o máximo de tokens de saída, a probabilidade de tokens de saída repetidos etc.
- Use as configurações de segurança para ajustar a probabilidade de receber respostas que possam ser consideradas nocivas.
Saiba mais sobre os modelos compatíveis
Aprenda mais sobre os modelos disponíveis para vários casos de uso, as cotas e os preços.Enviar feedback sobre sua experiência com o Firebase AI Logic