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


Vous pouvez demander à un modèle Gemini TTS de générer une sortie vocale (audio) à partir d'un prompt textuel. Lorsque vous utilisez Firebase AI Logic, vous pouvez effectuer cette demande directement depuis votre application.

La génération de synthèse vocale (TTS) est contrôlable, ce qui signifie que vous fournissez le texte exact à synthétiser en parole. Vous pouvez également utiliser le langage naturel dans vos requêtes pour définir le style, l'accent, le rythme et le ton de la sortie audio. Vous pouvez considérer la synthèse vocale comme l'opposé de la transcription (reconnaissance vocale).

Cette fonctionnalité est disponible avec tous les modèles Gemini -tts, qui sont optimisés pour la génération vocale de haute qualité et à faible latence.

Cette fonctionnalité vous permet, entre autres, de :

  • Narration interactive : créez des livres audio immersifs ou des jeux de rôle où le modèle change de voix pour différents personnages ou adapte son ton (en chuchotant pour créer du suspense ou en riant à une blague, par exemple) pour correspondre à la narration.

  • Apprentissage des langues : créez des guides de prononciation qui peuvent lire du texte avec des accents régionaux spécifiques ou à un rythme plus lent pour aider les apprenants à s'entraîner à prononcer des mots difficiles.

  • Lecteurs de contenu sensibles au contexte : lisez à voix haute des articles d'actualité, des recettes ou des articles de blog en utilisant une voix et un ton émotionnel adaptés au contenu (par exemple, un ton sérieux pour les dernières actualités ou un ton chaleureux et patient pour les instructions de cuisine détaillées).

Ce guide explique comment générer de la parole à partir d'une entrée de texte avec un ou plusieurs locuteurs, et comment diffuser la réponse audio.

 Accéder au code pour un seul haut-parleur  Accéder au code pour plusieurs haut-parleurs  Accéder au code pour les réponses diffusées

Comparaison entre la synthèse vocale 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 la parole à faible latence qui peuvent être configurés pour différentes voix et langues de réponse. Cependant, elles servent des cas d'utilisation très différents.

  • La génération de synthèse vocale (TTS) 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, de 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 et sortie vocales). Il excelle dans les contextes conversationnels dynamiques où le modèle décide de la réponse vocale à renvoyer. Notez que les derniers modèles Live API acceptent également 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 à ce fournisseur sur cette page.

Si ce n'est pas déjà fait, suivez le guide de démarrage, qui décrit comment configurer votre projet Firebase, associer 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 vos requêtes et les améliorer, nous vous recommandons d'utiliser Google AI Studio.

Modèles compatibles avec cette fonctionnalité

  • gemini-3.1-flash-tts-preview

Générer un discours à partir de texte

Vous pouvez générer de la parole à partir du texte fourni à l'aide d'un modèle TTS Gemini.

Générer une voix avec un seul locuteur

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Vous pouvez configurer le modèle pour qu'il génère du contenu audio à l'aide d'une seule voix.

Dans votre GenerationConfig, incluez les éléments suivants :

Appelez generateContent avec votre prompt textuel. Le modèle renvoie des données audio PCM brutes dans les parties 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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Say cheerfully: Have a wonderful day!"

// Call `generateContent` to generate the speech output based on your text prompt.
let response = try await model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
  let mimeType = part.mimeType  // for example: "audio/pcm"
  print("Received audio data with MIME type: \(mimeType)")

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

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.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Say cheerfully: Have a wonderful day!"

// Call `generateContent` to generate the speech output based on your text prompt.
val response = model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val pcmData = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    val mimeType = part.mimeType   // for example: "audio/pcm"

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

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.1-flash-tts-preview", config);

// Use the GenerativeModelFutures Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt.
String prompt = "Say cheerfully: Have a wonderful day!";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the 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[] pcmData = ((InlineDataPart) part).getInlineData();
            String mimeType = ((InlineDataPart) part).getMimeType();

            // To play back PCM audio data, you'll need to write your own `playAudio` function.
            playAudio(pcmData);
        }
    }

    @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.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt.
const prompt = "Say cheerfully: Have a wonderful day!";

// Call `generateContent` to generate the speech output based on your text prompt.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const pcmBase64 = inlineDataParts[0].inlineData.data;
  // Decode base64 to ArrayBuffer
  const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

  // To play back a PCM buffer, you'll need to write your own `playAudio` function.
  playAudio(pcmBuffer);
}

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: [ResponseModality.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.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt.
final prompt = 'Say cheerfully: Have a wonderful day!';

// Call `generateContent` to generate the speech output based on your text prompt.
final response = await model.generateContent([Content.text(prompt)]);

// Extract the 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 pcmData = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

  // To play back PCM audio data, you'll need to write your own `playAudio` function.
  await playAudio(pcmData);
}

Unity 


using Firebase.AI;

// 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")
);

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
);

// Provide a text prompt.
var prompt = "Say cheerfully: Have a wonderful day!";

// Call `GenerateContentAsync` to generate the speech output based on your text prompt.
var response = await model.GenerateContentAsync(prompt);

// Extract the 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[] pcmData = inlineData.Data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

      // To play back PCM audio data, you'll need to write your own `playAudio` function.
      playAudio(pcmData);
    }
  }
}

Générer une voix avec plusieurs locuteurs

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Vous pouvez configurer le modèle pour qu'il utilise différentes voix pour les différents locuteurs du texte. Cette fonctionnalité est utile pour générer de l'audio pour des dialogues ou des conversations.

  1. Créez un MultiSpeakerVoiceConfig qui mappe les noms des locuteurs (que vous utiliserez dans votre requête) à des noms de voix de réponse spécifiques (par exemple, Kore).

    La configuration à plusieurs locuteurs accepte exactement deux locuteurs.

  2. Dans votre GenerationConfig, incluez les éléments suivants :

    • Définissez responseModalities pour inclure AUDIO.

    • Configurez un SpeechConfig avec les éléments suivants :

  3. Dans votre requête, indiquez qui parle en utilisant les noms des locuteurs comme préfixes (par exemple, Joe: Hello. Jane: Hi.).

Appelez generateContent avec votre prompt textuel. Le modèle renvoie des données audio PCM brutes dans les parties de la réponse.

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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt that includes the names of the speakers.
let prompt = """
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
"""

// Call `generateContent` to generate the speech output based on your text prompt.
let response = try await model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
  let mimeType = part.mimeType  // for example: "audio/pcm"
  print("Received audio data with MIME type: \(mimeType)")

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

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.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt that includes the names of the speakers.
val prompt = """
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
"""

// Call `generateContent` to generate the speech output based on your text prompt.
val response = model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val pcmData = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    val mimeType = part.mimeType   // for example: "audio/pcm"

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

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);

// 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.1-flash-tts-preview", config);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt that includes the names of the speakers.
String prompt = "Joe: How's it going today Jane?\nJane: Not too bad, how about you?";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the 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[] pcmData = ((InlineDataPart) part).getInlineData();  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
            String mimeType = ((InlineDataPart) part).getMimeType();   // for example: "audio/pcm"

            // To play back PCM audio data, you'll need to write your own `playAudio` function.
            playAudio(pcmData);
        }
    }

    @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.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt that includes the names of the speakers.
const prompt = `
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
`;

// Call `generateContent` to generate the speech output based on your text prompt.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const pcmBase64 = inlineDataParts[0].inlineData.data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
  const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

  // To play back a PCM buffer, you'll need to write your own `playAudio` function.
  playAudio(pcmBuffer);
}

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: [ResponseModality.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.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt that includes the names of the speakers.
final prompt = '''
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
''';

// Call `generateContent` to generate the speech output based on your text prompt.
final response = await model.generateContent([Content.text(prompt)]);

// Extract the 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 pcmData = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

  // To play back PCM audio data, you'll need to write your own `playAudio` function.
  await playAudio(pcmData);
}

Unity 


using Firebase.AI;

// 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);

// Set `responseModalities` to include `Audio`.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: multiSpeechConfig
);

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
);

// Provide a text prompt that includes the names of the speakers.
var prompt = "Joe: How's it going today Jane?\nJane: Not too bad, how about you?";

// Call `GenerateContentAsync` to generate the speech output based on your text prompt.
var response = await model.GenerateContentAsync(prompt);

// Extract the 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[] pcmData = inlineData.Data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

      // To play back PCM audio data, you'll need to write your own `playAudio` function.
      playAudio(pcmData);
    }
  }
}

Diffuser la réponse

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Vous pouvez obtenir des interactions plus rapides et une latence plus faible en diffusant la réponse audio au fur et à mesure de sa génération, au lieu d'attendre que le fichier audio entier soit terminé.

Le streaming de la parole générée est compatible avec les configurations à une seule voix et à plusieurs voix. Elle n'est compatible qu'avec les modèles Gemini 3.x TTS.

Pour diffuser la réponse vocale en streaming, appelez generateContentStream au lieu de generateContent et gérez les blocs à mesure qu'ils arrivent. Les exemples suivants montrent comment diffuser une réponse à une seule voix :

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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Tell me a story about a brave knight."

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
let responseStream = try model.generateContentStream(prompt)

// Extract the audio data and handle it for downstream use. For example:
for try await chunk in responseStream {
  for part in chunk.inlineDataParts {
    let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
    let mimeType = part.mimeType  // for example: "audio/pcm"

    // Append the audio chunk to your audio queue/buffer for playback.
    appendAudioChunk(data)
  }
}

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.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Tell me a story about a brave knight."

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
// Extract the audio data and handle it for downstream use.
model.generateContentStream(prompt).collect { chunk ->
    val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
    if (part is InlineDataPart) {
        val pcmChunk = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
        val mimeType = part.mimeType    // for example: "audio/pcm"

        // Append the audio chunk to your audio queue/buffer for playback.
        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.1-flash-tts-preview", config);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt.
String prompt = "Tell me a story about a brave knight.";
Content content = new Content.Builder().addText(prompt).build();

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

// Extract the audio data and handle it for downstream use.
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();  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
          String mimeType = ((InlineDataPart) part).getMimeType();    // for example: "audio/pcm"

          // Append the audio chunk to your audio queue/buffer for playback.
          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.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt.
const prompt = "Tell me a story about a brave knight.";

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
const result = await model.generateContentStream(prompt);

// Extract the audio data and handle it for downstream use. For example:
const playbackQueue = [];
for await (const chunk of result.stream) {
  const inlineDataParts = chunk.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const pcmBase64 = inlineDataParts[0].inlineData.data;  // 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.
    playbackQueue.push(pcmBuffer);
  }
}

// To play back an array of PCM buffers in sequence, you'll need to write your own `processPlaybackQueue` function.
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: [ResponseModality.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.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt.
final prompt = 'Tell me a story about a brave knight.';

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
final responseStream = model.generateContentStream([Content.text(prompt)]);

// Extract the audio data and handle it for downstream use. For example:
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;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback.
    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.1-flash-tts-preview",
    generationConfig: config
);

// Provide a text prompt.
var prompt = "Tell me a story about a brave knight.";

// Call `GenerateContentStreamAsync` to generate the speech output stream based on your text prompt.
var responseStream = model.GenerateContentStreamAsync(prompt);

// Extract the audio data and handle it for downstream use. For example:
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; // Raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback.
        appendAudioChunk(pcmChunk);
    }
}


Contrôler la sortie vocale avec des requêtes

Vous pouvez influencer le ton, le rythme et le style de la parole générée à l'aide de techniques de prompting spécifiques.

Les sous-sections suivantes sur la structure des requêtes et les tags audio décrivent des conseils généraux. Pour obtenir des conseils détaillés, consultez ce guide sur les requêtes.

Structure de requête

Pour obtenir les meilleurs résultats, structurez votre requête avec les composants suivants :

  • Audio Profile : décrivez la personnalité, l'identité principale et l'archétype de l'orateur (par exemple, A warm, professional narrator).

  • Scene : décrivez l'environnement et l'ambiance émotionnelle (par exemple, In a quiet library ou Amidst a noisy crowd).

  • Director's Notes : décrivez l'émotion, le rythme, le style et l'accent (par exemple, Speak slowly and with mystery).

  • Sample Context : donnez un point de départ au modèle (par exemple, The speaker is greeting a close friend).

  • Transcription : texte à prononcer. Pour obtenir les meilleures performances, assurez-vous que le ton et le contexte du texte correspondent au profil vocal et aux notes de mise en scène.

Exemple de prompt :

[Audio Profile: A young, energetic voice]
[Scene: A lively sports broadcast]
[Director's Notes: Speak fast, with high energy and excitement]
[Sample Context: The game just ended with a last-second touchdown]
Welcome back fans! What an incredible game we're witnessing today!

Tags audio

Vous pouvez insérer des balises de mise en forme directement dans votre prompt textuel pour guider les performances du modèle.

Les balises audio ne sont compatibles qu'avec les modèles Gemini 3.x TTS.

Voici quelques-uns des tags communément utilisés :

  • [whispers] : chuchoter
  • [laughs] : pour ajouter un rire
  • [giggles] : pour ajouter des rires
  • [sighs] : ajouter un soupir
  • [gasp] : pour ajouter un halètement
  • [shouting] : crier
  • [excited] : parler avec enthousiasme
  • [serious] : parler sérieusement
  • [sighs whispers] : émotions combinées (vous pouvez combiner des tags)

Tenez compte des points suivants lorsque vous utilisez des tags audio :

  • Pas de liste exhaustive : il n'existe pas de liste fixe des balises acceptées. Vous pouvez tester différentes émotions et expressions (comme [bored], [sarcastically] ou même [like dracula]) pour voir comment le résultat change.

  • Prompt textuel dans une autre langue que l'anglais : si votre prompt textuel n'est pas en anglais, vous devez quand même utiliser des tags audio en anglais pour obtenir les meilleurs résultats.

Exemple de prompt :

I have a secret to tell you. [whispers] I found the hidden treasure. [laughs] I can't believe it!


Limites et exigences

Tenez compte des limites et des exigences suivantes lorsque vous utilisez la génération vocale :

  • La configuration à plusieurs locuteurs accepte exactement deux locuteurs.

  • Les fonctionnalités suivantes ne sont disponibles que lorsque vous utilisez les modèles Gemini 3.x TTS : le streaming, les tags audio et les langues supplémentaires détectées automatiquement.

Contraintes pour gemini-3.1-flash-tts-preview

  • Incohérence de la voix : la sortie du modèle ne correspond pas toujours strictement au locuteur sélectionné si le ton et le contexte de votre requête ne correspondent pas au profil du locuteur (par exemple, une voix masculine grave qui tente de parler comme une jeune fille). Assurez-vous que le contexte de votre requête correspond à la voix.
  • Sorties plus longues : la qualité et la cohérence de la voix peuvent se dégrader pour les contenus audio de plus de quelques minutes. Nous vous recommandons de diviser les longues requêtes textuelles en plusieurs parties plus petites.
  • Retour occasionnel de jetons de texte : le modèle renvoie parfois des jetons de texte au lieu de jetons audio, ce qui entraîne l'échec de la requête avec une erreur 500. Comme cela se produit de manière aléatoire dans un faible pourcentage de requêtes, vous devez implémenter une logique de nouvelle tentative dans votre application.
  • Faux rejets du classificateur : les requêtes vagues peuvent échouer au niveau du classificateur de synthèse vocale, ce qui entraîne un refus de la requête (PROHIBITED_CONTENT) ou amène le modèle à lire à voix haute vos instructions de style. Pour éviter cela, utilisez une requête structurée avec un préambule clair (comme Audio Profile et Director's Notes) au début de la requête.


Voix et langues compatibles

Les modèles TTS Gemini prennent du texte en entrée et génèrent une sortie audio. La réponse est donc la synthèse vocale elle-même. Les sous-sections suivantes listent les voix et les langues compatibles avec lesquelles les modèles TTS Gemini peuvent "parler" (ou répondre).

Les voix sont multilingues, ce qui signifie que vous pouvez utiliser la même voix pour générer de la parole dans n'importe quelle langue acceptée. Par exemple, vous pouvez définir la voix sur Kore et envoyer un ensemble de requêtes textuelles en espagnol, en hindi et en vietnamien. Les réponses seront toutes dans la voix de Kore, mais dans chacune de ces différentes langues.

Noms des voix

Les modèles TTS Gemini sont compatibles avec 30 voix HD synthétisées différentes, chacune ayant des caractéristiques distinctes. Vous pouvez afficher la liste des options de voix pour les réponses et écouter des démos de chaque voix en développant la section ci-dessous.

Langues

Les modèles TTS Gemini peuvent détecter automatiquement les langues suivantes dans votre prompt textuel. La voix générée sera dans cette langue.

Notez que vous pouvez éventuellement définir explicitement un code de langue dans votre configuration vocale.

Langues prises en charge par tous les modèles de génération audio
Langue Code BCP-47 Langue Code BCP-47
Arabe (Égypte) ar-EG Allemand (Allemagne) de-DE
Anglais (États-Unis) en-US Espagnol (États-Unis) es-US
Français (France) fr-FR Hindi (Inde) hi-IN
Indonésien (Indonésie) id-ID Italien (Italie) it-IT
Japonais (Japon) ja-JP Coréen (Corée) ko-KR
Portugais (Brésil) pt-BR Russe (Russie) ru-RU
Néerlandais (Pays-Bas) nl-NL Polonais (Pologne) pl-PL
Thaï (Thaïlande) th-TH Turc (Turquie) tr-TR
Vietnamien (Viêt Nam) vi-VN Roumain (Roumanie) ro-RO
Ukrainien (Ukraine) uk-UA Bengali (Bangladesh) bn-BD
Anglais (Inde) Pack en-IN et hi-IN Marathi (Inde) mr-IN
Tamoul (Inde) ta-IN Télougou (Inde) te-IN
Langues supplémentaires acceptées par les modèles 3.x de génération audio
Langue Code BCP-47 Langue Code BCP-47
Afrikaans af Filipino fil
Albanais sq Finnois fi
Amharique a.m. Galicien gl
Arménien hy Géorgien ka
Azéri az Grec el
Basque eu Gujarati gu
Biélorusse b Créole haïtien ht
Bulgare bg Hébreu il
Birman mon Hongrois hu
Catalan ca Islandais est
Cebuano ceb Javanais jv
Chinois (mandarin) cmn Kannada kn
Croate h Konkani kok
Tchèque cs Laotien lo
Danois da Latin la
Estonien et Letton lv
Lituanien lt Luxembourgeois lb
Macédonien mk Maithili mai
Malgache mg Malais ms
Malayalam ml Mongol mn
Népalais ne Norvégien, Bokmål nb
Norvégien, Nynorsk nn Odia ou
Pachto ps Perse fa
Panjabi pa Serbe sr
Sindhî sd Cingalais si
Slovaque sk Slovène sl
Swahili sw Suédois sv
Urdu ur

(Facultatif) Définir explicitement un code de langue

Si vous ne spécifiez pas de code de langue dans votre configuration vocale, le modèle détecte automatiquement la langue dans votre prompt textuel.

Toutefois, vous pouvez éventuellement définir explicitement la langue (à l'aide du paramètre languageCode dans la configuration vocale). Pour ce faire, vous devez utiliser l'un des codes de paramètres régionaux BCP-47 compatibles suivants :

  • Arabe : ar-XA
  • Bengali : bn-IN
  • Chinois (mandarin) : cmn-CN
  • Néerlandais : nl-NL
  • Anglais : en-US, en-GB, en-AU, en-IN
  • Français : fr-FR, fr-CA
  • Allemand : de-DE
  • Gujarati : gu-IN
  • Hindi : hi-IN
  • Indonésien : id-ID
  • Italien : it-IT
  • Japonais : ja-JP
  • Kannada : kn-IN
  • Coréen : ko-KR
  • Malayalam : ml-IN
  • Marathi : mr-IN
  • Polish : pl-PL
  • Portugais : pt-BR
  • Russe : ru-RU
  • Espagnol : es-US, es-ES
  • Tamoul : ta-IN
  • Télougou : te-IN
  • Thaï : th-TH
  • Turc : tr-TR
  • Vietnamien : vi-VN


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

Essayer d'autres fonctionnalités

Contrôler la génération de contenu

Vous pouvez également tester des requêtes 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