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


Vous pouvez demander à un modèle TTS Gemini de générer une sortie vocale (audio) à partir d'un prompt textuel. Lorsque vous utilisez Firebase AI Logic, vous pouvez effectuer cette requête 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 voix. Vous pouvez également utiliser le langage naturel dans vos prompts pour définir le style, l'accent, le rythme et le ton de la sortie audio. La synthèse vocale est l'opposé de la transcription (reconnaissance vocale).

Cette fonctionnalité est disponible avec n'importe quel modèle Gemini -tts, optimisé pour une génération vocale de haute qualité et à faible latence.

Cette fonctionnalité vous permet d'effectuer les opérations suivantes :

  • Storytelling interactif : créez des livres audio immersifs ou des jeux de rôle dans lesquels le modèle change de voix pour différents personnages ou adapte son ton (par exemple, en chuchotant pour créer du suspense ou en riant à une blague) pour correspondre au récit.

  • Apprentissage des langues : créez des guides de prononciation capables de 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 contextuels : lisez à voix haute des articles d'actualité, des recettes ou des articles de blog en utilisant un personnage vocal et un ton émotionnel correspondant au contenu (par exemple, un ton sérieux pour une alerte info ou un ton chaleureux et patient pour des instructions de cuisine étape par étape).

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

Accéder au code pour un seul locuteur Accéder au code pour plusieurs locuteurs Accéder au code pour les réponses diffusées en 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 ce n'est 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.1-flash-tts-preview

Générer un discours par synthèse vocale

Vous pouvez générer des voix à partir d'un texte fourni à l'aide d'un modèle TTS Gemini.

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.

Vous pouvez configurer le modèle pour qu'il génère de l'audio avec 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: [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.1-flash-tts-preview',
  generationConfig: 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 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 configurer le modèle pour qu'il utilise différentes voix pour différents locuteurs dans le texte. Cette fonctionnalité est utile pour générer des contenus 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 multilocuteur 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 prompt, indiquez qui parle en utilisant les noms des intervenants 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: [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.1-flash-tts-preview',
  generationConfig: 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 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 accélérer les interactions et réduire la latence en diffusant la réponse audio en streaming au fur et à mesure de sa génération, au lieu d'attendre que l'intégralité du fichier audio soit terminée.

Le streaming de la voix générée est compatible avec les configurations à un seul locuteur et à plusieurs locuteurs. Il n'est compatible qu'avec les modèles Gemini 3.x TTS.

Pour diffuser la réponse vocale, appelez generateContentStream au lieu de generateContent et gérez les fragments à mesure qu'ils arrivent. Les exemples suivants montrent comment diffuser une réponse à un seul locuteur :

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: [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.1-flash-tts-preview',
  generationConfig: 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 du discours généré à l'aide de techniques de prompting spécifiques.

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

Structure de requête

Pour obtenir de meilleurs résultats, structurez votre prompt avec les composants suivants :

  • Audio Profile : décrivez le persona, l'identité principale et l'archétype de l'intervenant (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 des performances optimales, assurez-vous que le ton et le contexte du texte écrit correspondent au profil vocal et aux notes de direction.

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 tags audio ne sont compatibles qu'avec les modèles Gemini 3.x TTS.

Voici quelques-unes des balises les plus couramment utilisées :

  • [whispers] : parler à voix basse
  • [laughs] : pour ajouter des rires
  • [giggles] : pour ajouter des rires
  • [sighs] : pour 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 de 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 tout de même utiliser des tags audio en anglais pour obtenir de 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 de voix :

  • La configuration multilocuteur accepte exactement deux locuteurs.

  • Les fonctionnalités suivantes ne sont compatibles qu'avec les modèles Gemini 3.x TTS : streaming, tags audio et 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 peut ne pas toujours correspondre 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 d'homme 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 varier pour les contenus audio de plus de quelques minutes. Nous vous recommandons de diviser les prompts textuels longs en plusieurs parties.
  • Retours occasionnels 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 le rejet de la requête (PROHIBITED_CONTENT) ou la lecture à voix haute de vos instructions de style par le modèle. 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 de synthèse vocale Gemini prennent une entrée de texte 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 que les modèles TTS Gemini peuvent "parler" (ou dans lesquelles ils peuvent répondre).

Les voix sont multilingues, ce qui signifie que vous pouvez utiliser la même voix pour générer des énoncés dans n'importe quelle langue compatible. Par exemple, vous pouvez définir la voix sur Kore et envoyer un ensemble de prompts textuels en espagnol, en hindi et en vietnamien. Les réponses seront toutes dans la voix Kore, mais dans chacune de ces 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 consulter la liste des options de voix de réponse 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. Le discours généré sera dans cette langue.

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

Langues compatibles avec 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 compatibles avec 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 de votre prompt textuel.

Toutefois, vous pouvez éventuellement définir explicitement la langue (à l'aide du paramètre languageCode dans la configuration de la reconnaissance vocale). Pour ce faire, vous devez utiliser l'un des codes 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
  • German: 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
  • Polonais : pl-PL
  • Portuguese: 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

Découvrez comment 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