Génération de synthèse vocale (TTS) à l'aide de l'API Gemini


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-tts
  • gemini-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 :

  1. Dans votre GenerationConfig, définissez responseModalities sur AUDIO et configurez un SpeechConfig avec les éléments suivants :

  2. Créez un fichier TextPart avec le contenu suivant :

    • (Obligatoire) Transcription textuelle à prononcer.

    • (Facultatif) Un SpeechMetadata avec une description style (par exemple, "cheerful and friendly").

  3. 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 type Publisher 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 :

  1. Créez un MultiSpeakerVoiceConfig qui mappe deux noms d'intervenants (par exemple, "Joe" et "Jane") à leurs voix SpeakerVoiceConfig.

  2. Dans votre GenerationConfig, définissez responseModalities sur AUDIO et transmettez votre MultiSpeakerVoiceConfig (et éventuellement languageCode) dans SpeechConfig.

  3. Fournissez un tableau ou une liste d'objets TextPart, plus précisément un objet TextPart par tour de dialogue. Sur chaque TextPart, définissez SpeechMetadata avec les éléments suivants :

    • (Obligatoire) speaker correspondant à l'un des noms d'intervenants définis dans votre MultiSpeakerVoiceConfig.
    • (Facultatif) Une description de style (par exemple, "cheerful and friendly").
  4. 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 type Publisher 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 type Publisher 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 style dans SpeechMetadata pour 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épliques TextPart distinctes, chacune avec son propre style.

  • 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."
  • 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!"

Bonnes pratiques pour la cohérence

  • Testez d'abord sans style, puis ajoutez des ajustements style concis : la plupart des requêtes semblent naturelles avec un champ style vide. Ajoutez une expression style courte (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'utiliser SpeechMetadata.style pour 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 :

  1. Parcourez et prévisualisez les voix à l'aide de l'une des options suivantes :

  2. Transmettez la chaîne id de la voix de la bibliothèque en tant que nom de voix dans SpeechConfig (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 :

  1. Créez la voix personnalisée une fois à l'aide de l'une de ces options :

  2. Transmettez la chaîne voice_<id> ou voicekey_<id> en tant que nom de voix dans SpeechConfig (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_... et voicekey_...) ne sont compatibles qu'avec l'emplacement global (qui est l'emplacement par défaut lors de l'utilisation de Firebase AI Logic).

  • Requêtes à un seul locuteur : MultiSpeakerVoiceConfig n'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, AVAudioPlayer sur les plates-formes Apple, Web Audio decodeAudioData ou les lecteurs basés sur des fichiers).

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 que responseModalities soit défini sur AUDIO.

  • 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 : MultiSpeakerVoiceConfig nécessite deux locuteurs et n'est compatible qu'avec les voix prédéfinies de base. Chaque TextPart d'une requête à plusieurs locuteurs doit inclure un SpeechMetadata.speaker correspondant à 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 responseFormat dans GenerationConfig pour remplacer le format de sortie audio par défaut.
    • La définition de systemInstruction, temperature, topP, topK, candidateCount, presencePenalty ou frequencyPenalty n'est pas acceptée et entraîne l'échec des requêtes avec une erreur 400 INVALID_ARGUMENT.
    • L'appel de countTokens n'est pas compatible avec les modèles TTS (les nombres de jetons sont renvoyés dans usageMetadata sur la réponse).
  • Emplacement (Agent Platform Gemini API (formerly Vertex AI)) : les voix personnalisées (voice_... et voicekey_...) nécessitent l'emplacement global (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 et
gemini-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 TextPart doit correspondre exactement à la transcription textuelle des paroles prononcées.

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 "uhm" directement dans le texte.

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 (generateContentStream) reste au format PCM 16 bits brut sans en-tête (audio/l16).

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-tts ou gemini-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 dans SpeechMetadata.style.

  • Diviser les scripts à plusieurs locuteurs en tours TextPart distincts : remplacez les blocs de texte "Joe: ... \n Jane: ..." par un tableau/une liste d'objets TextPart où chaque tour définit SpeechMetadata.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 generateContent renvoie 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 comme AudioTrack d'Android ou AudioClip d'Unity).

  • Supprimer les paramètres de configuration non compatibles : supprimez temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty et systemInstruction de votre configuration TTS GenerativeModel.



Qu'est-ce que tu sais faire d'autre ?

Essayer d'autres fonctionnalités

Découvrez comment contrôler la génération de contenu.

Vous pouvez également tester des prompts et des configurations de modèle, et même obtenir un extrait de code généré à l'aide de Google AI Studio.

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