使用 Gemini API 生成文字转语音 (TTS)


您可以要求 Gemini TTS 模型根据文本提示生成语音（音频）输出。使用 Firebase AI Logic 时，您可以直接从应用中发出此请求。

文字转语音 (TTS) 生成是可控的，这意味着您提供要合成语音的确切文本。此外，您还可以在提示中使用自然语言来指导音频输出的风格、口音、语速和语气。 您可以将 TTS 视为转写（语音转文字）的逆向过程。

此功能适用于任何 Gemini -tts 模型，这些模型经过优化，可生成高质量、低延迟的语音。

借助此功能，您可以执行以下操作：

  • 互动式故事讲述：创建沉浸式有声读物或角色扮演游戏，让模型为不同的角色切换声音，或调整语气（例如在悬念时低声细语，或在听到笑话时大笑），以贴合叙事内容。

  • 语言学习：构建发音指南，该指南可以采用特定的地区口音或以较慢的速度朗读文本，帮助学习者练习难以发音的词语。

  • 可感知上下文的内容阅读器：使用与内容相符的语音角色和情感基调（例如，使用严肃的语气朗读突发新闻，或使用温暖而耐心的语气朗读分步烹饪说明）大声朗读新闻报道、食谱或博文。

本指南介绍了如何使用单发言人或多发言人从文本输入生成语音，以及如何流式传输音频响应。

跳转到单音箱的代码 跳转到多音箱的代码 跳转到流式响应的代码

TTS 与 Live API 之间的比较

文字转语音 (TTS) 模型和 Live API 模型都是低延迟的语音生成模型，可以配置为使用不同的回答声音和语言。不过，它们的应用场景截然不同。

  • 文字转语音 (TTS) 生成是一种单向的请求-响应交互（输入文字，输出音频）。它专为需要准确朗读所提供文本并对风格和声音进行精细控制的场景而量身打造，例如播客旁白、有声读物或朗读文章。

  • Live API 生成支持 双向流式传输，可实现实时语音对话（语音输入、 语音输出）。它擅长处理动态对话上下文，在这种情况下，模型会决定要返回的适用语音。请注意，最新的 Live API 模型还支持视频和图片输入。

准备工作

点击您的 Gemini API 提供商，以查看此页面上特定于提供商的内容和代码。

如果您尚未完成入门指南，请先完成该指南。该指南介绍了如何设置 Firebase 项目、将应用连接到 Firebase、添加 SDK、为所选的 Gemini API 提供方初始化后端服务，以及创建 GenerativeModel 实例。

如需测试和迭代提示，我们建议使用 Google AI Studio。

支持此功能的模型

  • gemini-3.1-flash-tts-preview

根据文本生成语音

您可以使用 Gemini TTS 模型根据提供的文本生成语音。

生成包含单个发言人的语音

在试用此示例之前，请完成本指南的准备工作部分，以设置您的项目和应用。
在该部分中，您还需要点击所选Gemini API提供商对应的按钮，以便在本页上看到特定于提供商的内容。

您可以将模型配置为使用单一声音输出音频。

在您的 GenerationConfig 中，添加以下内容：

使用文本提示调用 generateContent。模型会在响应部分中返回原始 PCM 音频数据。

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

对于 Kotlin，此 SDK 中的方法是挂起函数，需要从 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

对于 Java，此 SDK 中的流式传输方法会返回 Reactive Streams 库中的 Publisher 类型。 

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

生成包含多个发言人的语音

在试用此示例之前，请完成本指南的准备工作部分，以设置您的项目和应用。
在该部分中，您还需要点击所选Gemini API提供商对应的按钮，以便在本页上看到特定于提供商的内容。

您可以将模型配置为针对文本中的不同说话者使用不同的语音。这对于为对话或谈话生成音频非常有用。

  1. 创建一个 MultiSpeakerVoiceConfig，将发言者姓名（您将在提示中使用）映射到特定的回答语音名称（例如 Kore）。

    多扬声器配置恰好支持 2 个扬声器。

  2. 在您的 GenerationConfig 中，添加以下内容：

    • 将 responseModalities 设置为包含 AUDIO。

    • 配置具有以下内容的 SpeechConfig：

  3. 在提示中，使用发言者姓名作为前缀（例如 Joe: Hello. Jane: Hi.）来指明发言者。

使用文本提示调用 generateContent。模型会在响应部分中返回原始 PCM 音频数据。

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

对于 Kotlin，此 SDK 中的方法是挂起函数，需要从 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

对于 Java，此 SDK 中的流式传输方法会返回 Reactive Streams 库中的 Publisher 类型。 

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

以流式传输回答

在试用此示例之前，请完成本指南的准备工作部分，以设置您的项目和应用。
在该部分中，您还需要点击所选Gemini API提供商对应的按钮，以便在本页上看到特定于提供商的内容。

通过在生成音频响应时对其进行流式传输，而不是等待整个音频文件完成，您可以实现更快的互动和更低的延迟。

无论是单说话人还是多说话人配置，都支持生成语音的流式传输。仅在使用 Gemini 3.x TTS 模型时受支持。

如需以流式传输语音响应，请调用 generateContentStream 而不是 generateContent，并在接收到块时处理这些块。以下示例展示了如何以流式传输单音箱响应：

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

对于 Kotlin，此 SDK 中的方法是挂起函数，需要从 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

对于 Java，此 SDK 中的流式传输方法会返回 Reactive Streams 库中的 Publisher 类型。 

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


使用提示控制语音输出

您可以使用特定的提示技巧来影响生成的语音的语气、语速和风格。

以下关于提示结构和音频标记的小节介绍了高级别指南。如需详细指导，请参阅此提示指南。

提示结构

为获得最佳结果，请使用以下组件构建提示：

  • Audio Profile：描述说话者的角色、核心身份和原型（例如 A warm, professional narrator）。

  • Scene：描述环境和情绪氛围（例如 In a quiet library 或 Amidst a noisy crowd）。

  • Director's Notes：描述情绪、语速、风格和口音（例如 Speak slowly and with mystery）。

  • Sample Context：为模型提供起点（例如 The speaker is greeting a close friend）。

  • 转写内容：要朗读的实际文本。为获得最佳效果，请确保文本的写作语气和上下文与语音配置文件和导演注释保持一致。

提示示例：

[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!

音频标签

您可以将格式设置标记直接插入到文本提示中，以指导模型的表现。

只有在使用 Gemini 3.x TTS 模型时，系统才支持音频标记。

常用的标记包括：

  • [whispers]：以耳语方式说话
  • [laughs]：添加笑声
  • [giggles]：添加笑声
  • [sighs]：添加叹号
  • [gasp]：添加喘气声
  • [shouting]：大声喊叫
  • [excited]：兴奋地说话
  • [serious]：认真地说
  • [sighs whispers]：组合情绪（您可以组合标记）

使用音频标记时，请注意以下事项：

  • 没有详尽的列表：没有固定的受支持标记列表。您可以尝试使用不同的情绪和表情符号（例如 [bored]、[sarcastically] 甚至 [like dracula]），看看输出结果会发生什么变化。

  • 非英语文本提示：如果您的文本提示不是英语，您仍应使用英语音频标记，以获得最佳效果。

提示示例：

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


限制和要求

使用语音生成功能时，请注意以下限制和要求：

  • 多扬声器配置恰好支持 2 个扬声器。

  • 使用 Gemini 3.x TTS 模型时，仅支持以下功能：流式传输、音频标记和更多自动检测到的语言。

gemini-3.1-flash-tts-preview 的限制

  • 声音不一致：如果提示的语气和上下文与所选发言者的个人资料不一致（例如，低沉的男声试图像年轻女孩一样说话），模型的输出可能并不总是与所选发言者完全一致。确保提示上下文与语音相符。
  • 输出时间较长：对于时长超过几分钟的音频，语音质量和一致性可能会出现偏差。建议将长文本提示拆分为较小的块。
  • 偶尔返回文本 token：模型偶尔会返回文本 token 而不是音频 token，导致请求失败并显示 500 错误。由于这种情况仅在少数请求中随机发生，因此您应在应用中实现重试逻辑。
  • 分类器错误拒绝：模糊不清的提示可能会导致语音合成分类器失败，从而导致请求被拒绝 (PROHIBITED_CONTENT) 或导致模型大声朗读您的风格指令。为避免这种情况，请使用结构化提示，并在提示开头添加清晰的序言（例如 Audio Profile 和 Director's Notes）。


支持的语音和语言

Gemini TTS 模型接受文本输入并生成音频输出，因此响应是合成的语音本身。以下各部分列出了 Gemini TTS 模型可以“说出”（或回答）的受支持语音和语言。

这些语音支持多种语言，这意味着您可以使用同一种语音生成任何受支持语言的语音。例如，您可以将语音设置为 Kore，并发送一组西班牙语、印地语和越南语文本提示。所有回答都将使用 Kore 语音，但会使用不同的语言。

语音名称

Gemini TTS 模型支持 30 种不同的合成高清语音，每种语音都具有独特的特征。您可以展开即可下部分，查看回答语音选项列表并试听每种语音。

语言

Gemini TTS 模型可以自动检测文本提示中的以下语言。生成的语音将采用该语言。

请注意，您也可以选择在语音配置中明确设置语言代码。

所有音频生成模型支持的语言
语言 BCP-47 代码 语言 BCP-47 代码
阿拉伯语（埃及语） ar-EG 德语（德国） de-DE
英语（美国） en-US 西班牙语（美国） es-US
法语（法国） fr-FR 印地语（印度） hi-IN
印度尼西亚语（印度尼西亚） id-ID 意大利语（意大利） it-IT
日语（日本） ja-JP 韩语（韩国） ko-KR
葡萄牙语（巴西） pt-BR 俄语（俄罗斯） ru-RU
荷兰语（荷兰） nl-NL 波兰语（波兰） pl-PL
泰语（泰国） th-TH 土耳其语（土耳其） tr-TR
越南语（越南） vi-VN 罗马尼亚语（罗马尼亚） ro-RO
乌克兰语（乌克兰） uk-UA 孟加拉语（孟加拉） bn-BD
英语（印度） en-IN 和 hi-IN 捆绑包 马拉地语（印度） mr-IN
泰米尔语（印度） ta-IN 泰卢固语（印度） te-IN
音频生成 3.x 模型支持的其他语言
语言 BCP-47 代码 语言 BCP-47 代码
南非荷兰语 南非荷兰语 菲律宾语 fil
阿尔巴尼亚语 阿尔巴尼亚语 芬兰语 芬兰语
阿姆哈拉语 阿姆哈拉语 加利西亚语 加利西亚语
亚美尼亚语 亚美尼亚语 格鲁吉亚语 格鲁吉亚语
阿塞拜疆语 阿塞拜疆语 希腊语 希腊语
巴斯克语 eu 古吉拉特语 古吉拉特语
白俄罗斯语 be 海地克里奥尔语 ht
保加利亚语 保加利亚语 希伯来语 he
缅甸语 缅甸语 匈牙利语 匈牙利语
加泰罗尼亚语 ca 冰岛语 是
宿务语 ceb 爪哇语 jv
中文（普通话） cmn 卡纳达语 卡纳达语
克罗地亚语 小时 贡根语 kok
捷克语 cs 老挝语 lo
丹麦语 丹麦语 拉丁语 la
爱沙尼亚语 爱沙尼亚语 拉脱维亚语 lv
立陶宛语 lt 卢森堡语 lb
马其顿语 马其顿语 迈蒂利语 mai
马尔加什语 mg 马来语 ms
马拉雅拉姆语 马拉雅拉姆语 蒙古语 mn
尼泊尔语 尼泊尔语 挪威语（博克马尔语） nb
挪威语（尼诺斯克语） nn 奥里亚语 或
普什图语 ps 波斯语 波斯语
旁遮普语 旁遮普语 塞尔维亚语 sr
信德语 sd 僧伽罗文 si
斯洛伐克语 sk 斯洛文尼亚语 斯洛文尼亚语
斯瓦希里语 sw 瑞典语 瑞典语
乌尔都语 乌尔都语

（可选）明确设置语言代码

如果您未在语音配置中指定语言代码，模型会自动检测文本提示中的语言。

不过，您也可以选择明确设置语言（使用语音配置中的 languageCode 参数）。为此，您必须使用以下受支持的 BCP-47 语言区域代码之一：

  • 阿拉伯语：ar-XA
  • 孟加拉语：bn-IN
  • 中文（普通话）：cmn-CN
  • 荷兰语：nl-NL
  • 英语：en-US、en-GB、en-AU、en-IN
  • 法语：fr-FR、fr-CA
  • 德语：de-DE
  • 古吉拉特语：gu-IN
  • 印地语：hi-IN
  • 印度尼西亚语：id-ID
  • 意大利语：it-IT
  • 日语：ja-JP
  • 卡纳达语：kn-IN
  • 韩语：ko-KR
  • 马拉雅拉姆语：ml-IN
  • 马拉地语：mr-IN
  • 波兰语：pl-PL
  • 葡萄牙语：pt-BR
  • 俄语：ru-RU
  • 西班牙语：es-US、es-ES
  • 泰米尔语：ta-IN
  • 泰卢固语：te-IN
  • 泰语：th-TH
  • 土耳其语：tr-TR
  • 越南语：vi-VN


您还可以做些什么？

试用其他功能

了解如何控制内容生成

您还可以尝试使用提示和模型配置，甚至可以使用 Google AI Studio 获取生成的代码段。

详细了解支持的型号

了解适用于各种应用场景的模型及其配额和价格。


就您使用 Firebase AI Logic 的体验提供反馈