Puedes usar un modelo de TTS de Gemini (gemini-3.8-flash-tts o
gemini-3.8-flash-lite-tts) para sintetizar voz (audio) natural y expresiva
a partir de texto. Cuando usas Firebase AI Logic, puedes realizar esta solicitud
directamente desde tu app web o para dispositivos móviles (como tu app de Apple (Swift), Android
(Kotlin/Java), Web (JavaScript), Flutter (Dart) o Unity).
La generación de texto a voz (TTS) es controlable, lo que significa que proporcionas el texto exacto para sintetizarlo en voz, mientras guías la entrega, como la emoción, el ritmo, las voces de los interlocutores y los sonidos que no son de voz, como risas o suspiros, con metadatos estructurados y etiquetas vocales intercaladas. Puedes pensar en TTS como lo opuesto a la transcripción (voz a texto).
Con esta función, puedes crear funciones como las siguientes:
- Narración interactiva y audiolibros: Narra historias de formato largo o juegos de rol en los que los personajes cambian de voz, reaccionan entre sí con canales de retroalimentación superpuestos y adaptan su expresión emocional (como susurrar en suspenso o reírse de un chiste).
- Asistentes y agentes de voz de baja latencia: Transmite voz sintetizada en cuanto llegue el texto de un LLM, lo que mantiene una personificación de voz coherente en todos los turnos de conversación.
- Lectores de contenido multilingüe y tutores de idiomas: Lee artículos, recetas o material de estudio en voz alta en más de 130 idiomas y acentos regionales, o cambia de idioma sin problemas en una sola conversación.
En esta guía, se muestra cómo generar voz de un solo interlocutor y de varios, transmitir
respuestas de audio, dirigir la entrega de voz con SpeechMetadata y etiquetas intercaladas, y elegir entre voces precompiladas, de biblioteca o personalizadas.
Saltar al código de un solo interlocutor Saltar al código de varios interlocutores Saltar al código de transmisión
Comparación entre TTS y Live API
Tanto los modelos de texto a voz (TTS) como los de Live API son modelos de baja latencia que generan voz y se pueden configurar para diferentes voces y lenguajes de respuesta. Sin embargo, se usan para casos de uso muy diferentes.
La generación de texto a voz (TTS) es una interacción unidireccional de solicitud y respuesta (entrada de texto, salida de audio). Está adaptado para situaciones que requieren una recitación exacta del texto proporcionado con un control detallado del estilo y el sonido, como la narración de podcasts, audiolibros o la lectura de artículos en voz alta.
La generación Live API admite la transmisión bidireccional para conversaciones de voz en tiempo real (entrada y salida de voz). Se destaca en contextos conversacionales dinámicos en los que el modelo decide el discurso aplicable que se debe mostrar. Ten en cuenta que los modelos de Live API más recientes también admiten entradas de video y de imagen.
Antes de comenzar
|
Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página. |
Si aún no lo hiciste, completa la
guía de introducción, en la que se describe cómo
configurar tu proyecto de Firebase, conectar tu app a Firebase, agregar el SDK,
inicializar el servicio de backend para el proveedor de Gemini API que elijas y
crear una instancia de GenerativeModel.
Para probar y, luego, iterar tus instrucciones, te recomendamos usar Google AI Studio.
Modelos que admiten esta capacidad
gemini-3.8-flash-ttsgemini-3.8-flash-lite-tts
Comparación de modelos de TTS
Ambos modelos de Gemini 3.x TTS tienen el mismo esquema de solicitud y formato de instrucción. Sin embargo, aquí se presentan algunas diferencias para cuando uses cada modelo.
| Función o carga de trabajo | gemini-3.8-flash-tts |
gemini-3.8-flash-lite-tts |
|---|---|---|
| Fortaleza principal | Fidelidad de voz de nivel de estudio, matices de actuación y amplia cobertura de dialectos | Alta capacidad de procesamiento, baja latencia y rentabilidad |
| Mejores casos de uso | Audiolibros, narración de estudio, diálogo complejo de varios interlocutores, etiquetas frecuentes de ráfagas de voz, pronunciación difícil, dialectos regionales | Producción de gran volumen, cascadas de agentes de voz en tiempo real, funciones de la IU de lectura en voz alta, voz de un solo interlocutor para el día a día |
| Idiomas compatibles | 132 idiomas | 103 idiomas |
Generar voz a partir de texto
Puedes generar voz a partir de una entrada de texto con una voz de un solo interlocutor o un
diálogo de dos interlocutores, ya sea como un archivo WAV completo (generateContent) o como una
transmisión de audio PCM sin procesar de baja latencia (generateContentStream).
Genera voz con un solo interlocutor
|
Antes de probar este ejemplo, completa la sección
Antes de comenzar de esta guía
para configurar tu proyecto y app. En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página. |
Sigue estos pasos para generar audio de un solo interlocutor:
En tu
GenerationConfig, estableceresponseModalitiesenAUDIOy configura unSpeechConfigcon lo siguiente:(Obligatorio) Un nombre o ID de voz. Puede ser una voz precompilada como
Kore, un ID de voz de la Biblioteca de voces extendida o un ID devoice_.../voicekey_...de voz personalizada.(Opcional) Un código de idioma BCP-47. Si se omite, el modelo detecta el idioma automáticamente.
Crea un
TextPartcon lo siguiente:(Obligatorio) Es la transcripción textual que se pronunciará.
(Opcional) Un
SpeechMetadatacon una descripción destyle(por ejemplo,"cheerful and friendly").
Llama a
generateContent. De forma predeterminada, las solicitudes unarias devuelven un archivo de audio WAV (audio/wav) completo (PCM lineal de 16 bits, 24 kHz, mono, con un encabezado RIFF estándar de 44 bytes) en las partes de datos intercalados de la respuesta.
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
En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutina.
// 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
En Java, los métodos de transmisión de este SDK devuelven un tipoPublisher de la biblioteca de 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 voz con varios interlocutores
|
Antes de probar este ejemplo, completa la sección
Antes de comenzar de esta guía
para configurar tu proyecto y app. En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página. |
Puedes generar una conversación natural de dos interlocutores en una sola solicitud
asignando a cada interlocutor una voz distinta y pasando cada línea de diálogo como su
propio TextPart:
Crea un
MultiSpeakerVoiceConfigque asigne dos nombres de interlocutores (por ejemplo,"Joe"y"Jane") a susSpeakerVoiceConfigvoces.En tu
GenerationConfig, estableceresponseModalitiesenAUDIOy pasa tuMultiSpeakerVoiceConfig(ylanguageCodeopcional) aSpeechConfig.Proporciona un array o una lista de objetos
TextPart, específicamente unTextPartpor turno de diálogo. En cadaTextPart, configuraSpeechMetadatacon lo siguiente:- (Obligatorio) Es un
speakerque coincide con uno de los nombres de interlocutor definidos en tuMultiSpeakerVoiceConfig. - (Opcional) Una descripción de
style(por ejemplo,"cheerful and friendly").
- (Obligatorio) Es un
Llama a
generateContent. El modelo sintetiza la conversación completa y devuelve un archivo de 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
En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutina.
// 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
En Java, los métodos de transmisión de este SDK devuelven un tipoPublisher de la biblioteca de 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);
}
}
}
Transmite la respuesta
|
Antes de probar este ejemplo, completa la sección
Antes de comenzar de esta guía
para configurar tu proyecto y app. En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página. |
Para reducir el tiempo hasta el primer audio (TTFA) y la reproducción en tiempo real, puedes transmitir la respuesta de audio a medida que se genera, en lugar de esperar a que termine todo el clip. La transmisión funciona con configuraciones de una sola bocina y de varias bocinas.
Para transmitir voz, llama a generateContentStream en lugar de generateContent.
A diferencia de las solicitudes unarias (que devuelven un archivo WAV), las solicitudes de transmisión devuelven fragmentos de PCM sin encabezado, sin procesar, de 16 bits, con signo y con orden de bytes little-endian (audio/l16, 24 kHz, mono) para que puedas agregar cada fragmento directamente a tu búfer de salida de 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
En Kotlin, los métodos de este SDK son funciones de suspensión y se deben llamar desde un alcance de corrutina.
// 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
En Java, los métodos de transmisión de este SDK devuelven un tipoPublisher de la biblioteca de 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);
}
}
Controla la respuesta por voz con metadatos y etiquetas intercaladas
Los modelos Gemini 3.x TTS tratan el text dentro de cada TextPart
estrictamente como una transcripción literal que se debe decir en voz alta. No escribas
instrucciones narrativas (como "Say cheerfully:") dentro de la cadena de texto, o
el modelo podría leer esas palabras en voz alta.
Puedes dirigir la interpretación vocal con las siguientes técnicas:
style a nivel de turno y etiquetas de voz intercaladas
Divide las instrucciones de rendimiento por alcance entre SpeechMetadata y las etiquetas de corchetes angulares intercaladas (<...>).
| Permiso | Dónde colocarlo | Qué controla | Ejemplos |
|---|---|---|---|
|
A nivel de turno (se mantiene durante todo el turno) |
SpeechMetadata.style
|
Emoción, persona, tono, inflexión, tono y velocidad general del habla |
"cheerful and friendly","whispered, nervous","speaking rapidly","out of breath","sarcastic"
|
|
Momento determinado (localizado en un momento específico de la oración) |
Intercala en el texto de TextPart con <...>
|
Ráfagas vocales humanas que no sean de voz, respiraciones, pausas o cambios momentáneos en la entrega |
"Wait... <short pause> did you hear that? <gasp> Someone's at the door."
|
Ritmo, pausas, tono y énfasis
Puntuación y puntos suspensivos: Usa comas, guiones (
--) y puntos suspensivos (...) en la transcripción para crear frases y vacilaciones naturales.Etiquetas de pausa explícitas: Inserta
<short pause>o<long pause>intercaladas en el punto exacto en el que el interlocutor debe pausar:Hold on, let me think... <short pause> Alright, I've got it.Velocidad de habla y tono: Configura
styleenSpeechMetadatapara controlar el ritmo, el tono o la inflexión generales del turno (por ejemplo,"speaking rapidly and excitedly","speaking slowly"o"monotone and flat"). Si la emoción o el ritmo cambian a mitad del monólogo, divide el guion en turnos deTextPartindependientes, cada uno con su propiostyle.Énfasis en las palabras: Escribe en mayúscula palabras específicas de la transcripción para destacarlas:
It was a VERY long day <sigh> ... nobody listens anymore.
Estallidos vocales y sonidos no verbales
Inserta vocalizaciones humanas que no sean de voz de forma intercalada con corchetes angulares (<...>)
en el límite exacto de la palabra donde debe producirse el sonido. Usa vocalizaciones humanas
en lugar de efectos de sonido no vocales. Estas son las etiquetas recomendadas que puedes usar:
<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> |
Canales de retroalimentación y voces superpuestas
En el diálogo de varios interlocutores, puedes encerrar las reacciones breves de los oyentes entre caracteres de barra vertical (|reaction|) dentro de la transcripción del interlocutor activo. El interlocutor no activo interviene de forma natural en ese punto sin necesidad de un turno separado:
Respuestas breves del oyente:
- 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 (
Voz superpuesta: Puedes usar varios segmentos de barra vertical para simular la voz simultánea (funciona mejor con
gemini-3.8-flash-tts), como los siguientes:- 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ácticas recomendadas para mantener la coherencia
Primero, realiza pruebas sin
styley, luego, agrega ajustes concisos destyle: La mayoría de las solicitudes suenan naturales con un campostylevacío. Agrega una frase corta destyle(como"casual, friendly"o"reflective and awe-inspired") solo cuando un turno necesite un ajuste de publicación específico y vuelve a usar esa misma cadena corta en todos los turnos cuando quieras una base coherente.Escribe transcripciones de voz naturales: Incluye contracciones conversacionales y disfluencias naturales (como
"Oh, uh, yeah I think... hm, that's interesting") directamente en el texto de la transcripción.Evita los bloques
[Audio Profile]heredados y las metainstrucciones: Los párrafos largos de personas, los bloques[Director's Notes]o las metainstrucciones como"maintain identical timbre"aumentan la desviación de la voz. En su lugar, elige una voz coincidente de la Biblioteca de voces extendida o crea una voz de personaje persistente con Diseño de voz.No intentes anular los rasgos de voz inmutables en
style: Evita usarSpeechMetadata.stylepara cambiar la edad, el género o el acento permanente de una voz. En su lugar, selecciona o diseña una voz con esas características.
Voces admitidas
Los modelos Gemini 3.x TTS admiten tres formas de especificar una voz:
Todas las voces son multilingües, lo que significa que puedes usar la misma voz para generar
voz en cualquiera de los idiomas admitidos y, al mismo tiempo, mantener una
identidad de interlocutor coherente. Por ejemplo, si configuras la voz en la voz precompilada
Kore y envías instrucciones en español, hindi y vietnamita, todas las respuestas
usarán la voz Kore en cada uno de esos idiomas. Si bien las
30 voces precompiladas principales son voces multilingües de uso general, las voces de la biblioteca de voces extendida y las
voces personalizadas están vinculadas a una configuración regional principal o a un acento
regional. Esto significa que pueden hablar otros idiomas, pero suenan más auténticos en su configuración regional principal.
Voces prediseñadas principales
Los modelos de TTS de Gemini admiten 30 voces precompiladas principales (como Kore,
Puck, Zephyr, Charon y Fenrir), cada una con características vocales
distintas. Pasa el nombre de la voz en SpeechConfig (como se muestra en los ejemplos de una sola bocina y varias bocinas que aparecen antes en esta página).
Voces predeterminadas de la biblioteca de voces extendida
Además de las 30 voces precompiladas, la biblioteca de voces extendida proporciona más de 2,000 voces predeterminadas seleccionadas que abarcan diversos idiomas, acentos regionales, rangos de edad, personajes y casos de uso (como audiolibros, agentes de asistencia al cliente y lectores de noticias).
A continuación, se explica cómo usar cualquier voz de la biblioteca de voces extendida en tu app:
Explora y obtén una vista previa de las voces con una de estas opciones:
Usa Google AI Studio o Agent Studio para obtener la voz
id.Consulta el método
listde la API de Voices (ListVoicescontype=prebuilty una consultasearchopcional) para obtener elidde voz. Obtén más información en la documentación de Gemini Developer API o en la documentación de Agent Platform Gemini API (formerly Vertex AI).
Pasa la cadena
idde la voz de la biblioteca como el nombre de la voz enSpeechConfig(similar a lo que se muestra en el ejemplo de un solo interlocutor que aparece antes en esta página).
Voces personalizadas: Diseño y replicación de voz
Los modelos Gemini 3.x TTS también admiten voces personalizadas con cualquiera de las siguientes opciones:
Diseño de voz (versión preliminar): Genera una voz personalizada única a partir de una descripción en lenguaje natural de la edad, el timbre vocal, el acento y la personalidad de un interlocutor (sin necesidad de ningún audio de referencia). Devuelve un ID de voz almacenado (
voice_...).Replicación de voz (versión preliminar): Replica la voz, el tono y la cadencia de un interlocutor a partir de una grabación de referencia y una grabación de consentimiento hablado. Devuelve un ID de voz almacenado en el proyecto (
voice_...) o una clave de replicación de voz sin estado administrada por la app (voicekey_...).
Usa una voz personalizada en tu app de Firebase AI Logic
La creación y administración de voces personalizadas es una operación administrativa o del servidor, por lo que los SDK cliente de Firebase AI Logic no exponen directamente los extremos de administración de voces (CreateVoice, ListVoices, DeleteVoice).
En su lugar, para usar una voz personalizada, debes hacer lo siguiente:
Crea la voz personalizada una vez con una de estas opciones:
Usa Google AI Studio o Agent Studio para obtener tu identificador de
voice_<id>ovoicekey_<id>.Usa la API de Voices para obtener tu identificador
voice_<id>ovoicekey_<id>. Obtén más información en la documentación del proveedor de Gemini API que elegiste:Gemini Developer API: Generación de voz
Agent Platform Gemini API (formerly Vertex AI): Diseño de voz y Replicación de voz
Pasa la cadena
voice_<id>ovoicekey_<id>como el nombre de la voz enSpeechConfig(similar a lo que se muestra en el ejemplo de un solo interlocutor que aparece antes en esta página).
Ten en cuenta los siguientes requisitos cuando uses voces personalizadas:
Ubicación (Agent Platform Gemini API (formerly Vertex AI)): Las voces personalizadas (
voice_...yvoicekey_...) solo se admiten en la ubicaciónglobal(que es la ubicación predeterminada cuando se usa Firebase AI Logic).Solicitudes de un solo interlocutor:
MultiSpeakerVoiceConfigsolo admite las voces precompiladas principales. Para usar voces diseñadas o replicadas de forma personalizada en un diálogo de varios personajes, sintetiza el turno de cada personaje en una solicitud de un solo interlocutor independiente.Retención y vencimiento: Las voces personalizadas almacenadas (
voice_...) vencen si no se usan durante 1 año (cada solicitud de síntesis restablece el temporizador de retención de 1 año); las claves de replicación de voz sin estado (voicekey_...) vencen 7 días después de la creación.
Lenguajes compatibles
Los modelos Gemini 3.x TTS detectan automáticamente el idioma de tu texto de entrada, incluso cuando una instrucción cambia de idioma en los turnos de un diálogo de varios interlocutores.
- Gemini 3.8 Flash TTS (
gemini-3.8-flash-tts): Admite 132 idiomas. - Gemini 3.8 Flash‑Lite TTS (
gemini-3.8-flash-lite-tts): Admite 103 idiomas.
(Opcional) Establece un código de idioma de forma explícita
Si quieres restringir de forma explícita la síntesis de voz a una configuración regional específica, puedes
pasar un languageCode de BCP-47 en tu SpeechConfig:
Formatos de salida de audio
El formato de audio predeterminado que se muestra en InlineDataPart depende de si
realizas una solicitud unaria o de transmisión:
| Método de solicitud | Tipo de MIME predeterminado que se devuelve | Detalles del formato de audio |
|---|---|---|
|
Unario ( generateContent)
|
audio/wav
|
Archivo WAV completo (PCM lineal de 16 bits, 24 kHz, mono,
little-endian) con un encabezado RIFF estándar de 44 bytes.
Se puede reproducir directamente con reproductores de audio de plataformas estándar (como
|
|
Transmisión ( generateContentStream)
|
audio/l16
|
Fragmentos de PCM sin encabezado, sin procesar, de 16 bits, con signo y con formato little-endian
a 24 kHz, mono.
Está diseñado para la puesta en cola de búferes y la concatenación de baja latencia sin encabezados de archivo por fragmento. |
Limitaciones y requisitos
Ten en cuenta las siguientes limitaciones y requisitos cuando uses los modelos de Gemini 3.x TTS:
Entrada solo de texto, salida solo de audio: Los modelos de TTS solo aceptan entradas de texto (
TextPart) y requieren queresponseModalitiesse establezca enAUDIO.Solo síntesis textual: Los modelos recitan la transcripción proporcionada textualmente y no generan respuestas de texto conversacionales.
Límites de tokens: La entrada máxima es de 8,192 tokens y la salida máxima es de 16,384 tokens por solicitud.
Límite de varios interlocutores:
MultiSpeakerVoiceConfigrequiere 2 interlocutores y solo admite voces precompiladas principales. CadaTextParten una solicitud de varios interlocutores debe incluir unSpeechMetadata.speakerque coincida con uno de los interlocutores configurados.Parámetros y métodos no admitidos:
- Los SDK de Firebase AI Logic todavía no admiten la configuración de
responseFormatenGenerationConfigpara anular el formato de salida de audio predeterminado. - No se admite la configuración de
systemInstruction,temperature,topP,topK,candidateCount,presencePenaltyofrequencyPenalty, y hace que las solicitudes fallen con un error400 INVALID_ARGUMENT. - No se admite la llamada a
countTokenspara los modelos de TTS (los recuentos de tokens se devuelven enusageMetadataen la respuesta).
- Los SDK de Firebase AI Logic todavía no admiten la configuración de
Ubicación (Agent Platform Gemini API (formerly Vertex AI)): Las voces personalizadas (
voice_...yvoicekey_...) requieren la ubicaciónglobal(que es la ubicación predeterminada cuando se usa Firebase AI Logic).
Migra desde gemini-3.1-flash-tts-preview
Tanto gemini-3.8-flash-tts como gemini-3.8-flash-lite-tts usan la misma
estructura de solicitud. Revisa la
tabla de comparación de modelos para elegir el mejor
reemplazo para tu carga de trabajo y actualiza tu código de la siguiente manera:
| Área |
gemini-3.1-flash-tts-preview (heredada)
|
gemini-3.8-flash-tts ygemini-3.8-flash-lite-tts
|
|---|---|---|
| Estilo y dirección de la presentación |
Incorporado en el texto de la instrucción. Por ejemplo:"Say cheerfully: ...",[Audio Profile],[Director's Notes]
|
Se pasa en SpeechMetadata(style: "...") en cada
TextPart
Mantén el texto de |
| Diálogo con varios interlocutores |
Cadena de texto única con prefijos "Speaker: ..." intercalados
|
Un TextPart por turno de diálogo, con
SpeechMetadata(speaker: "...", style: "...") en cada
TextPart
|
| Etiquetas de voz intercaladas |
Corchetes. Por ejemplo,[sigh] o [laughs]
|
Corchetes angulares. Por ejemplo,<sigh>,
<laugh> o
<short pause>
Escribe las disfluencias habladas, como |
Formato de audio unario predeterminado
(generateContent)
|
PCM sin procesar de 16 bits sin encabezado (audio/pcm, 24 kHz, mono)
|
Archivo WAV completo (audio/wav, PCM de 16 bits,
24 kHz, mono, con un encabezado RIFF de 44 bytes)
La transmisión
( |
| Instrucciones del sistema, temperatura, top-P y top-K | Ignorada |
Se rechazó con un error 400 INVALID_ARGUMENT. Quita estos
parámetros de la configuración del modelo.
|
Lista de tareas para la migración
Actualiza a la versión más reciente del SDK de Firebase AI Logic y cambia el nombre de tu modelo a
gemini-3.8-flash-ttsogemini-3.8-flash-lite-tts.Mueve las instrucciones de estilo a
SpeechMetadata.style: Quita los prefijos"Say cheerfully:",[Audio Profile],[Scene]y[Director's Notes]de tus cadenas de instrucciones para que el modelo no las lea en voz alta. En su lugar, pasa una descripción de estilo concisa enSpeechMetadata.style.Divide los guiones de varios interlocutores en turnos de
TextPartindependientes: Reemplaza los bloques de texto"Joe: ... \n Jane: ..."por un array o una lista de objetosTextParten los que cada turno establezcaSpeechMetadata.speaker.Convierte las etiquetas
[...]en etiquetas<...>: Reemplaza las etiquetas de audio entre corchetes (como[whispers],[sighs]y[laughs]) por etiquetas de voz entre corchetes angulares (como<whispers>,<sigh>,<laugh>y<short pause>).Actualiza la reproducción de audio unario: Debido a que
generateContentahora devuelve un archivo WAV completo (con un encabezado RIFF de 44 bytes) en lugar de PCM sin procesar y sin encabezado, quita cualquier código que anteponga de forma manual un encabezado WAV a las respuestas unarias (o omite el encabezado de 44 bytes si ingresas muestras de PCM sin procesar en una API de búfer de bajo nivel, comoAudioTrackde Android oAudioClipde Unity).Quita los parámetros de configuración no admitidos: Quita
temperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyysystemInstructionde tu configuración de TTSGenerativeModel.
¿Qué más puedes hacer?
-
Comienza a pensar en la preparación para la producción (consulta la
lista de tareas de producción):
- Aplica de manera forzosa Firebase App Check lo antes posible para ayudar a proteger Gemini API contra el abuso de clientes no autorizados.
- Usa Firebase Remote Config o plantillas de instrucciones del servidor para que puedas realizar cambios a pedido en la configuración de tu función de IA (como el nombre del modelo) sin lanzar una versión nueva de la app.
Prueba otras funciones
- Crea conversaciones de varios turnos (chat).
- Generar texto a partir de instrucciones solo de texto
- Generar resultados estructurados (como JSON) a partir de instrucciones de texto y multimodales
- Generar y editar imágenes a partir de instrucciones de texto y multimodales
- Transmite la entrada y la salida (incluido el audio) con Gemini Live API.
-
Usa herramientas (como la llamada a funciones
y la fundamentación con
Google Search oGoogle Maps ) para conectar un modelo de Gemini a otras partes de tu app y a sistemas e información externos.
Aprende a controlar la generación de contenido
- Comprende el diseño de instrucciones, incluidas las prácticas recomendadas, las estrategias y las instrucciones de ejemplo.
- Configura los parámetros del modelo, como la cantidad máxima de tokens de salida, la probabilidad de que se repitan los tokens de salida, etcétera.
- Usa la configuración de seguridad para ajustar la probabilidad de obtener respuestas que puedan considerarse dañinas.
Más información sobre los modelos compatibles
Obtén información sobre los modelos disponibles para varios casos de uso, sus cuotas y sus precios.Envía comentarios sobre tu experiencia con Firebase AI Logic