Geração de conversão de texto em voz (TTS) usando a API Gemini


É possível pedir a um modelo de TTS Gemini para gerar uma saída de fala (áudio) com base em um comando de texto. Ao usar Firebase AI Logic, você pode fazer essa solicitação diretamente do seu aplicativo.

A geração de conversão de texto em voz (TTS) é controlável, ou seja, você fornece o texto exato para sintetizar em fala. Além disso, você pode usar linguagem natural nos comandos para orientar o estilo, o sotaque, o ritmo e o tom da saída de áudio. Pense na TTS como o oposto da transcrição (conversão de voz em texto).

Esse recurso está disponível usando qualquer um dos modelos Gemini -tts, que são otimizados para geração de fala de alta qualidade e baixa latência.

Com esse recurso, é possível:

  • Narrativa interativa: crie audiolivros imersivos ou jogos de RPG em que o modelo muda de voz para diferentes personagens ou adapta o tom (como sussurrar em suspense ou rir de uma piada) para corresponder à narrativa.

  • Aprendizado de idiomas: crie guias de pronúncia que podem ler texto com sotaques regionais específicos ou em ritmo mais lento para ajudar os estudantes a praticar pronúncias difíceis.

  • Leitores de conteúdo com reconhecimento de contexto: leem artigos de notícias, receitas ou postagens de blog em voz alta usando uma personalidade de voz e um tom emocional que correspondem ao conteúdo (como um tom sério para notícias de última hora ou um tom caloroso e paciente para instruções de culinária passo a passo).

Este guia mostra como gerar fala a partir de entrada de texto com um ou vários falantes e como transmitir a resposta de áudio.

Ir para o código de um único alto-falante Ir para o código de vários alto-falantes Ir para o código de respostas transmitidas

Comparação entre a TTS e o Live API

Os modelos de conversão de texto em fala (TTS) e Live API são modelos de baixa latência e geração de fala que podem ser configurados para diferentes vozes de resposta e idiomas. No entanto, eles atendem a casos de uso muito diferentes.

  • A geração de conversão de texto em voz (TTS) é uma interação unidirecional de solicitação-resposta (texto na entrada, áudio na saída). Ele é personalizado para cenários que exigem recitação exata do texto fornecido com controle refinado sobre estilo e som, como narração de podcasts, audiolivros ou leitura de artigos em voz alta.

  • A geração de Live API oferece suporte ao streaming bidirecional para conversas por voz em tempo real (voz de entrada e saída). Ele se destaca em contextos de conversas dinâmicas em que o modelo decide a fala aplicável a ser retornada. Os modelos Live API mais recentes também aceitam entradas de vídeo e imagem.

Antes de começar

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página.

Se ainda não tiver feito isso, conclua o guia de primeiros passos, que descreve como configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK, inicializar o serviço de back-end para o provedor Gemini API escolhido e criar uma instância GenerativeModel.

Para testar e iterar em comandos, recomendamos usar Google AI Studio.

Modelos compatíveis com essa funcionalidade

  • gemini-3.1-flash-tts-preview

Gerar fala com base em texto

É possível gerar fala com base no texto fornecido usando um modelo de TTS Gemini.

Gerar fala com um único locutor

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão para o provedor Gemini API escolhido para ver conteúdo específico do provedor nesta página.

Você pode configurar o modelo para gerar áudio usando uma única voz.

No seu GenerationConfig, inclua o seguinte:

Chame generateContent com seu comando de texto. O modelo retorna dados brutos de áudio em PCM nas partes da resposta.

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

Para Kotlin, os métodos nesse SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina. 

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

Para Java, os métodos de streaming neste SDK retornam um tipo Publisher da biblioteca 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);
    }
  }
}

Gerar fala com vários locutores

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão para o provedor Gemini API escolhido para ver conteúdo específico do provedor nesta página.

É possível configurar o modelo para usar vozes diferentes para cada locutor no texto. Isso é útil para gerar áudio para diálogos ou conversas.

  1. Crie um MultiSpeakerVoiceConfig que mapeie os nomes dos alto-falantes (que você vai usar no comando) para nomes de vozes de resposta específicos (por exemplo, Kore).

    A configuração com vários falantes é compatível com exatamente dois falantes.

  2. No seu GenerationConfig, inclua o seguinte:

    • Defina responseModalities para incluir AUDIO.

    • Configure um SpeechConfig com o seguinte:

  3. No comando, indique quem está falando usando os nomes dos participantes como prefixos (por exemplo, Joe: Hello. Jane: Hi.).

Chame generateContent com seu comando de texto. O modelo retorna dados brutos de áudio em PCM nas partes da resposta.

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

Para Kotlin, os métodos nesse SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina. 

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

Para Java, os métodos de streaming neste SDK retornam um tipo Publisher da biblioteca 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);
    }
  }
}

Mostrar composição da resposta

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão para o provedor Gemini API escolhido para ver conteúdo específico do provedor nesta página.

Para ter interações mais rápidas e menor latência, faça streaming da resposta de áudio à medida que ela é gerada, em vez de esperar que todo o arquivo de áudio seja concluído.

O streaming da fala gerada é compatível com configurações de um único falante e vários falantes. Ela só é compatível com os modelos Gemini 3.x TTS.

Para transmitir a resposta de voz, chame generateContentStream em vez de generateContent e processe os blocos à medida que chegam. Os exemplos a seguir mostram como transmitir uma resposta de um único falante:

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

Para Kotlin, os métodos nesse SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina. 

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

Para Java, os métodos de streaming neste SDK retornam um tipo Publisher da biblioteca 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);
    }
}


Controlar a saída de voz com comandos

Você pode influenciar o tom, o ritmo e o estilo da fala gerada usando técnicas de comando específicas.

As subseções a seguir sobre estrutura de comandos e tags de áudio descrevem orientações de alto nível. Para orientações detalhadas, consulte este guia de comandos.

Estrutura do comando

Para ter os melhores resultados, estruture seu comando com os seguintes componentes:

  • Audio Profile: descreva a persona, a identidade principal e o arquétipo do falante (por exemplo, A warm, professional narrator).

  • Scene: descreva o ambiente e a atmosfera emocional (por exemplo, In a quiet library ou Amidst a noisy crowd).

  • Director's Notes: descreva a emoção, o ritmo, o estilo e o sotaque (por exemplo, Speak slowly and with mystery).

  • Sample Context: dê um ponto de partida ao modelo (por exemplo, The speaker is greeting a close friend).

  • Transcrição: o texto real a ser falado. Para ter o melhor desempenho, verifique se o tom e o contexto do texto estão alinhados com o perfil de voz e as observações de direção.

Exemplo de comando:

[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 de áudio

Você pode inserir tags de formatação diretamente no comando de texto para orientar a performance do modelo.

As tags de áudio só são compatíveis com os modelos Gemini 3.x TTS.

As tags usadas com frequência incluem:

  • [whispers]: falar em um sussurro
  • [laughs]: para adicionar risadas
  • [giggles]: para adicionar risadas
  • [sighs]: para adicionar um suspiro
  • [gasp]: para adicionar um suspiro
  • [shouting]: gritar
  • [excited]: falar com entusiasmo
  • [serious]: falar sério
  • [sighs whispers]: emoções combinadas (é possível combinar tags)

Ao usar tags de áudio, observe o seguinte:

  • Não há uma lista completa: não existe uma lista fixa de tags compatíveis. Você pode testar diferentes emoções e expressões (como [bored], [sarcastically] ou até mesmo [like dracula]) para ver como a saída muda.

  • Comando de texto em outro idioma: se o comando de texto não estiver em inglês, use tags de áudio em inglês para ter os melhores resultados.

Exemplo de comando:

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


Limitações e requisitos

Esteja ciente das seguintes limitações e requisitos ao usar a geração de fala:

  • A configuração com vários falantes é compatível com exatamente dois falantes.

  • Os seguintes recursos só são compatíveis quando se usam os modelos Gemini 3.x TTS: streaming, tags de áudio e outros idiomas detectados automaticamente.

Restrições para gemini-3.1-flash-tts-preview

  • Inconsistência de voz: a saída do modelo nem sempre corresponde ao falante selecionado se o tom e o contexto do comando não estiverem alinhados ao perfil do falante. Por exemplo, uma voz masculina grave tentando falar como uma menina. Verifique se o contexto do comando corresponde à voz.
  • Saídas mais longas: a qualidade e a consistência da fala podem variar em áudios com mais de alguns minutos. Recomendamos dividir comandos de texto longos em partes menores.
  • Retornos ocasionais de tokens de texto: às vezes, o modelo retorna tokens de texto em vez de tokens de áudio, fazendo com que a solicitação falhe com um erro 500. Como isso ocorre aleatoriamente em uma pequena porcentagem de solicitações, implemente uma lógica de novas tentativas no seu app.
  • Rejeições falsas do classificador: comandos vagos podem falhar no classificador de síntese de fala, resultando em uma solicitação rejeitada (PROHIBITED_CONTENT) ou fazendo com que o modelo leia suas instruções de estilo em voz alta. Para evitar isso, use um comando estruturado com um preâmbulo claro (como Audio Profile e Director's Notes) no início do comando.


Vozes e idiomas compatíveis

Os modelos de TTS Gemini recebem entradas de texto e geram saídas de áudio. Portanto, a resposta é a própria fala sintetizada. As subseções a seguir listam as vozes e os idiomas compatíveis que os modelos de TTS Gemini podem "falar" (ou responder).

As vozes são multilíngues, o que significa que você pode usar a mesma voz para gerar fala em qualquer um dos idiomas disponíveis. Por exemplo, você pode definir a voz como Kore e enviar um conjunto de comandos de texto em espanhol, hindi e vietnamita. As respostas serão todas na voz do Kore, mas em cada um desses idiomas diferentes.

Nomes de voz

Os modelos de TTS Gemini oferecem suporte a 30 vozes em alta definição sintetizadas diferentes, cada uma com características distintas. Você pode conferir uma lista de opções de voz de resposta e ouvir demonstrações de cada uma delas ao abrir a seção abaixo.

Idiomas

Os modelos de TTS do Gemini podem detectar automaticamente os seguintes idiomas no comando de texto. A fala gerada será nesse idioma.

Você também pode definir explicitamente um código de idioma na configuração de fala.

Idiomas aceitos por todos os modelos de geração de áudio
Idioma Código BCP-47 Idioma Código BCP-47
Árabe (egípcio) ar-EG Alemão (Alemanha) de-DE
Inglês (EUA) en-US Espanhol (EUA) es-US
Francês (França) fr-FR Híndi (Índia) hi-IN
Indonésio (Indonésia) id-ID Italiano (Itália) it-IT
Japonês (Japão) ja-JP Coreano (Coreia) ko-KR
Português (Brasil) pt-BR Russo (Rússia) ru-RU
Holandês (Holanda) nl-NL Polonês (Polônia) pl-PL
Tailandês (Tailândia) th-TH Turco (Turquia) tr-TR
Vietnamita (Vietnã) vi-VN Romeno (Romênia) ro-RO
Ucraniano (Ucrânia) uk-UA Bengali (Bangladesh) bn-BD
Inglês (Índia)‎ Pacote en-IN e hi-IN Marati (Índia) mr-IN
Tâmil (Índia) ta-IN Telugu (Índia) te-IN
Outros idiomas compatíveis com modelos 3.x de geração de áudio
Idioma Código BCP-47 Idioma Código BCP-47
Africâner af Filipino fil
Albanês sq Finlandês fi
Amárico am Galego gl
Armênio hy Georgiano ka
Azerbaijano az Grego el
Basco eu Gujarati gu
Bielorrusso be Crioulo haitiano ht
Búlgaro bg Hebraico he
Birmanês my Húngaro hu
Catalão ca Islandês é
Cebuano ceb Javanês jv
Chinês, mandarim cmn Canarês kn
Croata h Concani kok
Tcheco cs Laosiano lo
Dinamarquês da Latim la
Estoniano et Letão lv
Lituano lt Luxemburguês lb
Macedônio mk Maithili mai
Malgaxe mg Malaio ms
Malaiala ml Mongol mn
Nepalês ne Norueguês (Bokmål) nb
Norueguês (Nynorsk) nn Oriá ou
Pashto ps Persa fa
Punjabi pa Sérvio sr
Sindi sd Cingalês si
Eslovaco sk Esloveno sl
Suaíli sw Sueco sv
Urdu ur

(Opcional) Definir explicitamente um código de idioma

Se você não especificar um código de idioma na configuração de fala, o modelo detectará automaticamente o idioma no comando de texto.

No entanto, é possível definir explicitamente o idioma (usando o parâmetro languageCode na configuração de voz). Para isso, use um dos seguintes códigos de localidade BCP-47 compatíveis:

  • Árabe: ar-XA
  • Bengalês: bn-IN
  • Chinês (mandarim): cmn-CN
  • Holandês: nl-NL
  • Inglês: en-US, en-GB, en-AU, en-IN
  • Francês: fr-FR, fr-CA
  • Alemão: de-DE
  • Guzerate: gu-IN
  • Hindi: hi-IN
  • Indonésio: id-ID
  • Italiano: it-IT
  • Japonês: ja-JP
  • Canarês: kn-IN
  • Coreano: ko-KR
  • Malaiala: ml-IN
  • Marati: mr-IN
  • Polonês: pl-PL
  • Português: pt-BR
  • Russo: ru-RU
  • Espanhol: es-US, es-ES
  • Tâmil: ta-IN
  • Telugu: te-IN
  • Tailandês: th-TH
  • Turco: tr-TR
  • Vietnamita: vi-VN


O que mais você pode fazer?

Teste outros recursos

Saiba como controlar a geração de conteúdo

Você também pode testar comandos e configurações de modelo e até mesmo receber um snippet de código gerado usando Google AI Studio.

Saiba mais sobre os modelos compatíveis

Saiba mais sobre os modelos disponíveis para vários casos de uso e as cotas e preços.


Envie feedback sobre sua experiência com Firebase AI Logic