Vous pouvez utiliser un modèle TTS Gemini (gemini-3.8-flash-tts ou gemini-3.8-flash-lite-tts) pour synthétiser un discours naturel et expressif (audio) à partir de texte. Lorsque vous utilisez Firebase AI Logic, vous pouvez envoyer cette requête directement depuis votre application mobile ou Web (par exemple, votre application Apple (Swift), Android (Kotlin/Java), Web (JavaScript), Flutter (Dart) ou Unity).
La génération de synthèse vocale est contrôlable, ce qui signifie que vous fournissez le texte exact à synthétiser en voix, tout en guidant la diffusion (par exemple, l'émotion, le rythme, les voix des locuteurs et les sons non vocaux comme les rires ou les soupirs) à l'aide de métadonnées structurées et de balises vocales intégrées. La synthèse vocale est l'opposé de la transcription (reconnaissance vocale).
Cette fonctionnalité vous permet de créer des fonctionnalités telles que :
- Storytelling interactif et livres audio : racontez des histoires longues ou des jeux de rôle dans lesquels les personnages changent de voix, réagissent les uns aux autres avec des réactions qui se chevauchent et adaptent leur expression émotionnelle (par exemple, en chuchotant pour créer du suspense ou en riant à une blague).
- Agents et assistants vocaux à faible latence : diffusez la synthèse vocale dès que le texte arrive d'un LLM, en conservant un persona vocal cohérent tout au long des conversations.
- Lecteurs de contenus multilingues et tuteurs linguistiques : lisez des articles, des recettes ou des supports d'étude à voix haute dans plus de 130 langues et accents régionaux, ou changez de langue de manière fluide au cours d'une même conversation.
Ce guide explique comment générer des contenus vocaux à un ou plusieurs locuteurs, diffuser des réponses audio, diriger la diffusion vocale avec SpeechMetadata et des balises intégrées, et choisir parmi des voix prédéfinies, de bibliothèque ou personnalisées.
Accéder au code pour un seul locuteur Accéder au code pour plusieurs locuteurs Accéder au code pour le streaming
Comparaison entre TTS et Live API
Les modèles de synthèse vocale (TTS) et les modèles Live API sont des modèles de génération de voix à faible latence qui peuvent être configurés pour différentes voix et langues de réponse. Cependant, ils répondent à des cas d'utilisation très différents.
La génération de synthèse vocale est une interaction unidirectionnelle de type requête-réponse (texte en entrée, audio en sortie). Il est conçu pour les scénarios qui nécessitent une récitation exacte du texte fourni, avec un contrôle précis du style et du son, comme la narration de podcasts, les livres audio ou la lecture d'articles à voix haute.
La génération Live API est compatible avec le streaming bidirectionnel pour les conversations vocales en temps réel (entrée vocale, sortie vocale). Il excelle dans les contextes de conversation dynamiques où le modèle décide de la réponse vocale à renvoyer. Notez que les derniers modèles Live API sont également compatibles avec les entrées vidéo et image.
Avant de commencer
|
Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques au fournisseur sur cette page. |
Si vous ne l'avez pas déjà fait, suivez le guide de démarrage, qui explique comment configurer votre projet Firebase, connecter votre application à Firebase, ajouter le SDK, initialiser le service de backend pour le fournisseur Gemini API de votre choix et créer une instance GenerativeModel.
Pour tester et effectuer des itérations de vos requêtes, nous vous recommandons d'utiliser Google AI Studio.
Modèles compatibles avec cette fonctionnalité
gemini-3.8-flash-ttsgemini-3.8-flash-lite-tts
Comparaison des modèles TTS
Les deux modèles Gemini 3.x TTS ont le même schéma de requête et le même format de requête. Voici toutefois quelques différences qui peuvent vous aider à choisir le modèle à utiliser.
| Fonctionnalité ou charge de travail | gemini-3.8-flash-tts |
gemini-3.8-flash-lite-tts |
|---|---|---|
| Force principale | Fidélité vocale de qualité studio, nuances de jeu et large couverture des dialectes | Débit élevé, faible latence et rentabilité |
| Meilleurs cas d'utilisation | Livres audio, narration en studio, dialogues complexes entre plusieurs locuteurs, tags d'éclats de voix fréquents, prononciation difficile, dialectes régionaux | Production à fort volume, cascades d'agents vocaux en temps réel, fonctionnalités d'interface utilisateur de lecture à voix haute, voix quotidienne d'un seul locuteur |
| Langues dans lesquelles le service est disponible | 132 langues | 103 langues |
Générer un discours par synthèse vocale
Vous pouvez générer un discours à partir d'une entrée de texte avec une voix d'un seul locuteur ou un dialogue entre deux locuteurs, soit sous la forme d'un fichier WAV complet (generateContent), soit sous la forme d'un flux audio PCM brut à faible latence (generateContentStream).
Générer un discours avec un seul locuteur
|
Avant d'essayer cet exemple, suivez les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application. Dans cette section, vous cliquerez également sur un bouton correspondant au fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. |
Voici comment générer un contenu audio avec un seul locuteur :
Dans votre
GenerationConfig, définissezresponseModalitiessurAUDIOet configurez unSpeechConfigavec les éléments suivants :(Obligatoire) Nom ou ID de la voix. Il peut s'agir d'une voix prédéfinie comme
Kore, d'un ID de voix de la bibliothèque de voix étendue ou d'un ID de voix personnaliséevoice_.../voicekey_....(Facultatif) Un code de langue BCP-47. Si ce paramètre est omis, le modèle détecte automatiquement la langue.
Créez un fichier
TextPartavec le contenu suivant :(Obligatoire) Transcription textuelle à prononcer.
(Facultatif) Un
SpeechMetadataavec une descriptionstyle(par exemple,"cheerful and friendly").
Appelez le
generateContent. Par défaut, les requêtes unaires renvoient un fichier audio WAV (audio/wav) complet (PCM linéaire 16 bits, 24 kHz, mono, avec un en-tête RIFF standard de 44 octets) dans les parties de données intégrées de la réponse.
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
Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine.
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
responseModalities = listOf(ResponseModality.AUDIO)
speechConfig = SpeechConfig(
voice = Voice("Kore"),
languageCode = "en-US"
)
}
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "gemini-3.8-flash-tts",
generationConfig = config
)
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
text(
text = "Have a wonderful day!",
speechMetadata = SpeechMetadata(style = "cheerful and friendly")
)
}
// Call `generateContent` to generate the speech output.
val response = model.generateContent(prompt)
// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
val wavData = part.inlineData // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
playAudio(wavData)
}
Java
Pour Java, les méthodes de streaming de ce SDK renvoient un typePublisher de la bibliothèque 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);
}
}
}
Générer un discours avec plusieurs locuteurs
|
Avant d'essayer cet exemple, suivez les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application. Dans cette section, vous cliquerez également sur un bouton correspondant au fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. |
Vous pouvez générer une conversation naturelle entre deux locuteurs dans une seule requête en attribuant à chaque locuteur une voix distincte et en transmettant chaque ligne de dialogue en tant que TextPart :
Créez un
MultiSpeakerVoiceConfigqui mappe deux noms d'intervenants (par exemple,"Joe"et"Jane") à leurs voixSpeakerVoiceConfig.Dans votre
GenerationConfig, définissezresponseModalitiessurAUDIOet transmettez votreMultiSpeakerVoiceConfig(et éventuellementlanguageCode) dansSpeechConfig.Fournissez un tableau ou une liste d'objets
TextPart, plus précisément un objetTextPartpar tour de dialogue. Sur chaqueTextPart, définissezSpeechMetadataavec les éléments suivants :- (Obligatoire)
speakercorrespondant à l'un des noms d'intervenants définis dans votreMultiSpeakerVoiceConfig. - (Facultatif) Une description de
style(par exemple,"cheerful and friendly").
- (Obligatoire)
Appelez le
generateContent. Le modèle synthétise l'intégralité de la conversation et renvoie un fichier audio WAV (audio/wav) complet.
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
Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
val multiSpeechConfig = SpeechConfig(
multiSpeakerVoiceConfig = MultiSpeakerVoiceConfig(
speakerVoiceConfigs = listOf(
SpeakerVoiceConfig(speaker = "Joe", voice = Voice("Puck")),
SpeakerVoiceConfig(speaker = "Jane", voice = Voice("Kore"))
)
),
languageCode = "en-US"
)
// Set `responseModalities` to include `AUDIO`.
val config = generationConfig {
responseModalities = listOf(ResponseModality.AUDIO)
speechConfig = multiSpeechConfig
}
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "gemini-3.8-flash-tts",
generationConfig = config
)
// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
val prompt = content {
text(
text = "How's it going today, Jane?",
speechMetadata = SpeechMetadata(speaker = "Joe", style = "cheerful and friendly")
)
text(
text = "Not too bad, how about you?",
speechMetadata = SpeechMetadata(speaker = "Jane", style = "calm and relaxed")
)
}
// Call `generateContent` to generate the multi-speaker speech output.
val response = model.generateContent(prompt)
// Extract the WAV audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
val wavData = part.inlineData // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)
// Pass the audio data to your audio player or playback helper (which you'll need to implement).
playAudio(wavData)
}
Java
Pour Java, les méthodes de streaming de ce SDK renvoient un typePublisher de la bibliothèque 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);
}
}
}
Diffuser la réponse
|
Avant d'essayer cet exemple, suivez les instructions de la section Avant de commencer de ce guide pour configurer votre projet et votre application. Dans cette section, vous cliquerez également sur un bouton correspondant au fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page. |
Pour réduire le délai avant le premier audio (TTFA) et permettre une lecture en temps réel, vous pouvez diffuser la réponse audio au fur et à mesure de sa génération, au lieu d'attendre que l'intégralité du clip soit terminée. Le streaming fonctionne avec les configurations à un seul locuteur et à plusieurs locuteurs.
Pour diffuser de la voix, appelez generateContentStream au lieu de generateContent.
Contrairement aux requêtes unaires (qui renvoient un fichier WAV), les requêtes de streaming renvoient des fragments PCM bruts 16 bits signés little-endian sans en-tête (audio/l16, 24 kHz, mono). Vous pouvez ainsi ajouter chaque fragment directement à votre tampon de sortie 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
Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine.
// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
responseModalities = listOf(ResponseModality.AUDIO)
speechConfig = SpeechConfig(voice = Voice("Kore"))
}
// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
.generativeModel(
modelName = "gemini-3.8-flash-tts",
generationConfig = config
)
// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
text(
text = "Tell me a story about a brave knight.",
speechMetadata = SpeechMetadata(style = "warm, engaging audiobook narrator")
)
}
// Call `generateContentStream` to stream the speech output as it is generated.
// Extract the raw PCM audio chunks and queue them for playback.
model.generateContentStream(prompt).collect { chunk ->
val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
val pcmChunk = part.inlineData // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)
// Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
appendAudioChunk(pcmChunk)
}
}
Java
Pour Java, les méthodes de streaming de ce SDK renvoient un typePublisher de la bibliothèque 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);
}
}
Contrôler la sortie vocale avec des métadonnées et des tags intégrés
Les modèles Gemini 3.x TTS traitent le text à l'intérieur de chaque TextPart strictement comme une transcription textuelle à prononcer à voix haute. N'écrivez pas d'instructions narratives (telles que "Say cheerfully:") dans la chaîne de texte, sinon le modèle risque de lire ces mots à voix haute.
Vous pouvez diriger la performance vocale à l'aide des techniques suivantes :
style au niveau du tour de parole et tags vocaux intégrés
Séparez vos instructions de performances par champ d'application entre SpeechMetadata et les balises entre crochets intégrées (<...>).
| Champ d'application | Où placer | Ce qu'il contrôle | Exemples |
|---|---|---|---|
|
Au niveau du tour (maintenu pendant tout le tour) |
SpeechMetadata.style
|
Émotion, persona, ton, inflexion, hauteur et débit de parole global |
"cheerful and friendly","whispered, nervous","speaking rapidly","out of breath","sarcastic"
|
|
Ponctuel (localisé à un moment précis de la phrase) |
Intégrer dans le texte TextPart à l'aide de <...>
|
Éclats de voix, respirations, pauses ou changements momentanés de débit non verbaux |
"Wait... <short pause> did you hear that? <gasp> Someone's at the door."
|
Rythme, pauses, ton et accentuation
Ponctuation et points de suspension : utilisez des virgules, des tirets (
--) et des points de suspension (...) dans la transcription pour créer des formulations et des hésitations naturelles.Balises de pause explicites : insérez
<short pause>ou<long pause>de manière intégrée à l'endroit exact où l'orateur doit faire une pause :Hold on, let me think... <short pause> Alright, I've got it.Débit et hauteur de voix : définissez
styledansSpeechMetadatapour contrôler le rythme, la hauteur ou l'inflexion globale de la réplique (par exemple,"speaking rapidly and excitedly","speaking slowly"ou"monotone and flat"). Si l'émotion ou le rythme change au milieu d'un monologue, divisez le script en répliquesTextPartdistinctes, chacune avec son proprestyle.Mise en valeur des mots : mettez certains mots en majuscules dans la transcription pour les mettre en valeur :
It was a VERY long day <sigh> ... nobody listens anymore.
Sons vocaux et sons autres que la parole
Insérez des vocalisations humaines non vocales à l'aide de crochets (<...>) à la limite exacte du mot où le son doit se produire. Utilisez des vocalisations humaines plutôt que des effets sonores non vocaux. Voici les tags recommandés :
<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> |
Réponses minimales et chevauchement des voix
Dans un dialogue entre plusieurs locuteurs, vous pouvez placer les brèves réactions d'un auditeur entre des barres verticales (|reaction|) dans la transcription du locuteur actif. L'intervenant non actif intervient naturellement à ce moment-là sans avoir besoin d'un tour distinct :
Réponses courtes de l'auditeur :
- Tour 1 (
speaker: "Joe") :"So the launch is Thursday |oh hmm| Are we actually ready?" - Tour 2 (
speaker: "Jane") :"Ready enough |oh really?| The last blocker cleared this morning."
- Tour 1 (
Discours qui se chevauchent : vous pouvez utiliser plusieurs segments de barre verticale pour simuler un discours simultané (fonctionne mieux avec
gemini-3.8-flash-tts), par exemple :- Tour 1 (
speaker: "Joe") :"Let's surprise him on three |ok| ready?" - Tour 2 (
speaker: "Jane") :"one. two. three. |happy| happy |birthday| birthday!"
- Tour 1 (
Bonnes pratiques pour la cohérence
Testez d'abord sans
style, puis ajoutez des ajustementsstyleconcis : la plupart des requêtes semblent naturelles avec un champstylevide. Ajoutez une expressionstylecourte (comme"casual, friendly"ou"reflective and awe-inspired") uniquement lorsqu'un tour nécessite un ajustement de diffusion spécifique, et réutilisez cette même chaîne courte d'un tour à l'autre lorsque vous souhaitez une référence cohérente.Rédigez des transcriptions naturelles : incluez des contractions conversationnelles et des disfluences naturelles (comme
"Oh, uh, yeah I think... hm, that's interesting") directement dans le texte de la transcription.Évitez les anciens blocs
[Audio Profile]et les méta-instructions : les longs paragraphes de persona, les blocs[Director's Notes]ou les méta-instructions comme"maintain identical timbre"augmentent la dérive vocale. Choisissez plutôt une voix correspondante dans la bibliothèque de voix étendue ou créez une voix de personnage persistante avec la conception de voix.N'essayez pas de remplacer les caractéristiques vocales immuables dans
style: évitez d'utiliserSpeechMetadata.stylepour modifier l'âge, le genre ou l'accent permanent d'une voix. Sélectionnez ou concevez plutôt une voix présentant ces caractéristiques.
Voix compatibles
Les modèles Gemini 3.x TTS permettent de spécifier une voix de trois manières :
Toutes les voix sont multilingues, ce qui signifie que vous pouvez utiliser la même voix pour générer des énoncés dans l'une des langues compatibles tout en conservant une identité de locuteur cohérente. Par exemple, si vous définissez la voix sur la voix prédéfinie Kore et que vous envoyez des requêtes en espagnol, en hindi et en vietnamien, les réponses utilisent toutes la voix Kore dans chacune de ces langues. Les 30 voix principales prédéfinies sont des voix multilingues à usage général, tandis que les voix de la bibliothèque de voix étendue et les voix personnalisées sont ancrées dans un accent régional ou un paramètre régional principal. Cela signifie qu'ils peuvent toujours parler d'autres langues, mais qu'ils sont plus authentiques dans leurs paramètres régionaux principaux.
Voix prédéfinies de base
Les modèles TTS Gemini sont compatibles avec 30 voix prédéfinies principales (telles que Kore, Puck, Zephyr, Charon et Fenrir), chacune ayant des caractéristiques vocales distinctes. Transmettez le nom de la voix dans SpeechConfig (comme indiqué dans les exemples à un seul locuteur et à plusieurs locuteurs plus haut sur cette page).
Voix prédéfinies de la bibliothèque de voix étendue
En plus des 30 voix prédéfinies, la bibliothèque de voix étendue propose plus de 2 000 voix prédéfinies couvrant différentes langues, accents régionaux, tranches d'âge, personnages et cas d'utilisation (tels que les livres audio, les agents du service client et les présentateurs de journaux télévisés).
Voici comment utiliser n'importe quelle voix de la bibliothèque de voix étendue dans votre application :
Parcourez et prévisualisez les voix à l'aide de l'une des options suivantes :
Utilisez Google AI Studio ou Agent Studio pour obtenir la voix
id.Interrogez la méthode
listde l'API Voices (ListVoicesavectype=prebuiltet une requêtesearchfacultative) pour obtenir la voixid. Pour en savoir plus, consultez la documentation Gemini Developer API ou la documentation Agent Platform Gemini API (formerly Vertex AI).
Transmettez la chaîne
idde la voix de la bibliothèque en tant que nom de voix dansSpeechConfig(comme illustré dans l'exemple à un seul locuteur plus haut sur cette page).
Voix personnalisées : conception et réplication vocales
Les modèles Gemini 3.x TTS sont également compatibles avec les voix personnalisées à l'aide de l'une des options suivantes :
Conception vocale (preview) : générez une voix personnalisée unique à partir d'une description en langage naturel de l'âge, du timbre vocal, de l'accent et du personnage d'un locuteur (sans avoir besoin d'un fichier audio de référence). Renvoie un ID de voix stocké (
voice_...).Réplication vocale (preview) : répliquez la voix, le ton et le rythme d'un locuteur à partir d'un enregistrement de référence et d'un enregistrement de consentement oral. Renvoie un ID de voix stocké dans le projet (
voice_...) ou une clé de réplication vocale sans état gérée par l'application (voicekey_...).
Utiliser une voix personnalisée dans votre application Firebase AI Logic
La création et la gestion de voix personnalisées sont des opérations administratives ou côté serveur. Par conséquent, les SDK clients Firebase AI Logic n'exposent pas directement les points de terminaison de gestion des voix (CreateVoice, ListVoices, DeleteVoice).
Pour utiliser une voix personnalisée, vous devez procéder comme suit :
Créez la voix personnalisée une fois à l'aide de l'une de ces options :
Utilisez Google AI Studio ou Agent Studio pour obtenir votre identifiant
voice_<id>ouvoicekey_<id>.Utilisez l'API Voices pour obtenir votre identifiant
voice_<id>ouvoicekey_<id>. Pour en savoir plus, consultez la documentation du fournisseur Gemini API de votre choix :Gemini Developer API : Génération de voix
Agent Platform Gemini API (formerly Vertex AI) : Conception vocale et Réplication vocale
Transmettez la chaîne
voice_<id>ouvoicekey_<id>en tant que nom de voix dansSpeechConfig(comme indiqué dans l'exemple à un seul locuteur plus haut sur cette page).
Gardez à l'esprit les exigences suivantes lorsque vous utilisez des voix personnalisées :
Emplacement (Agent Platform Gemini API (formerly Vertex AI)) : les voix personnalisées (
voice_...etvoicekey_...) ne sont compatibles qu'avec l'emplacementglobal(qui est l'emplacement par défaut lors de l'utilisation de Firebase AI Logic).Requêtes à un seul locuteur :
MultiSpeakerVoiceConfign'est compatible qu'avec les voix prédéfinies de base. Pour utiliser des voix personnalisées ou répliquées dans un dialogue à plusieurs personnages, synthétisez le tour de chaque personnage dans une requête distincte à un seul locuteur.Conservation et expiration : les voix personnalisées stockées (
voice_...) expirent si elles ne sont pas utilisées pendant un an (chaque requête de synthèse réinitialise le minuteur de conservation d'un an). Les clés de réplication vocale sans état (voicekey_...) expirent sept jours après leur création.
Langues disponibles
Les modèles Gemini 3.x TTS détectent automatiquement la langue de votre texte d'entrée, y compris lorsqu'une requête change de langue d'un tour à l'autre dans un dialogue entre plusieurs locuteurs.
- Gemini 3.8 Flash TTS (
gemini-3.8-flash-tts) : compatible avec 132 langues. - Gemini 3.8 Flash‑Lite TTS (
gemini-3.8-flash-lite-tts) : compatible avec 103 langues.
(Facultatif) Définir explicitement un code de langue
Si vous souhaitez limiter explicitement la synthèse vocale à des paramètres régionaux spécifiques, vous pouvez transmettre un languageCode BCP-47 dans votre SpeechConfig :
Formats de sortie audio
Le format audio par défaut renvoyé dans InlineDataPart dépend du type de requête (unaire ou de streaming) :
| Méthode de requête | Type MIME renvoyé par défaut | Détails du format audio |
|---|---|---|
|
Unary ( generateContent)
|
audio/wav
|
Fichier WAV complet (PCM linéaire 16 bits, 24 kHz, mono, little-endian) avec un en-tête RIFF standard de 44 octets.
Peut être lu directement par les lecteurs audio standards de la plate-forme (par exemple, |
|
Streaming ( generateContentStream)
|
audio/l16
|
Morceaux PCM bruts 16 bits signés little-endian sans en-tête à 24 kHz, mono.
Conçu pour la mise en file d'attente et la concaténation de tampons à faible latence sans en-têtes de fichier par fragment. |
Limites et exigences
Gardez à l'esprit les limites et exigences suivantes lorsque vous utilisez les modèles Gemini 3.x TTS :
Entrée textuelle uniquement, sortie audio uniquement : les modèles TTS n'acceptent que les entrées textuelles (
TextPart) et nécessitent queresponseModalitiessoit défini surAUDIO.Synthèse textuelle uniquement : les modèles récitent la transcription fournie mot pour mot et ne génèrent pas de réponses textuelles conversationnelles.
Limites de jetons : le nombre maximal de jetons d'entrée est de 8 192 et le nombre maximal de jetons de sortie est de 16 384 par requête.
Limite de locuteurs :
MultiSpeakerVoiceConfignécessite deux locuteurs et n'est compatible qu'avec les voix prédéfinies de base. ChaqueTextPartd'une requête à plusieurs locuteurs doit inclure unSpeechMetadata.speakercorrespondant à l'un des locuteurs configurés.Paramètres et méthodes non compatibles :
- Les SDK Firebase AI Logic ne permettent pas encore de définir
responseFormatdansGenerationConfigpour remplacer le format de sortie audio par défaut. - La définition de
systemInstruction,temperature,topP,topK,candidateCount,presencePenaltyoufrequencyPenaltyn'est pas acceptée et entraîne l'échec des requêtes avec une erreur400 INVALID_ARGUMENT. - L'appel de
countTokensn'est pas compatible avec les modèles TTS (les nombres de jetons sont renvoyés dansusageMetadatasur la réponse).
- Les SDK Firebase AI Logic ne permettent pas encore de définir
Emplacement (Agent Platform Gemini API (formerly Vertex AI)) : les voix personnalisées (
voice_...etvoicekey_...) nécessitent l'emplacementglobal(qui est l'emplacement par défaut lors de l'utilisation de Firebase AI Logic).
Migrer depuis gemini-3.1-flash-tts-preview
gemini-3.8-flash-tts et gemini-3.8-flash-lite-tts utilisent la même structure de requête. Consultez le tableau de comparaison des modèles pour choisir le meilleur remplacement pour votre charge de travail, puis mettez à jour votre code comme suit :
| Zone |
gemini-3.1-flash-tts-preview (ancienne)
|
gemini-3.8-flash-tts etgemini-3.8-flash-lite-tts
|
|---|---|---|
| Style et direction de la diffusion |
Intégrée dans le texte du prompt. Par exemple :"Say cheerfully: ...",[Audio Profile],[Director's Notes]
|
Transmis dans SpeechMetadata(style: "...") sur chaque TextPart
Le texte |
| Dialogue entre plusieurs locuteurs |
Chaîne de texte unique avec des préfixes "Speaker: ..." intégrés
|
Un TextPart par tour de dialogue, avec SpeechMetadata(speaker: "...", style: "...") sur chaque TextPart
|
| Tags vocaux intégrés |
Crochets. Par exemple,[sigh] ou [laughs]
|
Chevrons. Par exemple,<sigh> ou
<laugh> ou
<short pause>
Écrivez les disfluences parlées telles que |
Format audio unaire par défaut (generateContent)
|
PCM 16 bits brut sans en-tête (audio/pcm, 24 kHz, mono)
|
Fichier WAV complet (audio/wav, PCM 16 bits, 24 kHz, mono, avec un en-tête RIFF de 44 octets)
Le streaming ( |
| Instructions système, température, top-P, top-K | Ignoré |
Refusé avec une erreur 400 INVALID_ARGUMENT. Supprimez ces paramètres de la configuration de votre modèle.
|
Checklist de migration
Passez à la dernière version du SDK Firebase AI Logic et remplacez le nom de votre modèle par
gemini-3.8-flash-ttsougemini-3.8-flash-lite-tts.Déplacez les instructions de style vers
SpeechMetadata.style: supprimez les préfixes"Say cheerfully:",[Audio Profile],[Scene]et les blocs[Director's Notes]de vos chaînes de prompt afin que le modèle ne les lise pas à voix haute. Transmettez plutôt une description de style concise dansSpeechMetadata.style.Diviser les scripts à plusieurs locuteurs en tours
TextPartdistincts : remplacez les blocs de texte"Joe: ... \n Jane: ..."par un tableau/une liste d'objetsTextPartoù chaque tour définitSpeechMetadata.speaker.Convertir les balises
[...]en balises<...>: remplacez les balises audio entre crochets (comme[whispers],[sighs],[laughs]) par des balises vocales entre crochets (comme<whispers>,<sigh>,<laugh>,<short pause>).Mettre à jour la lecture audio unaire : étant donné que
generateContentrenvoie désormais un fichier WAV complet (avec un en-tête RIFF de 44 octets) au lieu d'un PCM brut sans en-tête, supprimez tout code qui ajoute manuellement un en-tête WAV aux réponses unaires (ou ignorez l'en-tête de 44 octets si vous transmettez des échantillons PCM bruts à une API de tampon de bas niveau commeAudioTrackd'Android ouAudioClipd'Unity).Supprimer les paramètres de configuration non compatibles : supprimez
temperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyetsystemInstructionde votre configuration TTSGenerativeModel.
Qu'est-ce que tu sais faire d'autre ?
-
Commencez à réfléchir à la préparation de la production (consultez la checklist de production) :
- Appliquez Firebase App Check le plus tôt possible pour protéger Gemini API contre toute utilisation abusive par des clients non autorisés.
- Utilisez Firebase Remote Config ou des modèles de prompt de serveur pour pouvoir modifier à la demande les configurations de votre fonctionnalité d'IA (comme le nom du modèle) sans publier de nouvelle version de votre application.
Essayer d'autres fonctionnalités
- Créez des conversations multitours (chat).
- Générer du texte à partir de requêtes textuelles.
- Générer une sortie structurée (comme JSON) à partir de requêtes textuelles et multimodales.
- Générez et modifiez des images à partir de prompts textuels et multimodaux.
- Entrée et sortie de flux (y compris l'audio) à l'aide de Gemini Live API.
-
Utilisez des outils (comme l'appel de fonction et l'ancrage avec
Google Search ouGoogle Maps ) pour connecter un modèle Gemini à d'autres parties de votre application, ainsi qu'à des systèmes et informations externes.
Découvrez comment contrôler la génération de contenu.
- Comprendre la conception de requêtes, y compris les bonnes pratiques, les stratégies et des exemples de requêtes.
- Configurez les paramètres du modèle, tels que le nombre maximal de jetons de sortie, la probabilité de jetons de sortie répétés, etc.
- Utilisez les paramètres de sécurité pour ajuster la probabilité de recevoir des réponses pouvant être considérées comme nuisibles.
En savoir plus sur les modèles compatibles
Découvrez les modèles disponibles pour différents cas d'utilisation, ainsi que leurs quotas et leurs tarifs.Envoyer des commentaires sur votre expérience avec Firebase AI Logic