Generowanie tekstu na mowę (TTS) za pomocą interfejsu Gemini API


Możesz poprosić model TTS Gemini o wygenerowanie mowy (dźwięku) na podstawie promptu tekstowego. Jeśli korzystasz z Firebase AI Logic, możesz wysłać tę prośbę bezpośrednio z aplikacji.

Generowanie zamiany tekstu na mowę (TTS) jest kontrolowane, co oznacza, że podajesz dokładny tekst, który ma zostać przekształcony na mowę. Możesz też używać języka naturalnego w promptach, aby określić styl, akcent, tempo i ton wygenerowanego dźwięku. Zamiana tekstu na mowę jest przeciwieństwem transkrypcji (zamiany mowy na tekst).

Ta funkcja jest dostępna w przypadku wszystkich modeli Gemini -tts, które są zoptymalizowane pod kątem wysokiej jakości generowania mowy z niskim opóźnieniem.

Dzięki tej funkcji możesz:

  • Interaktywne opowiadanie historii: twórz wciągające audiobooki lub gry fabularne, w których model zmienia głosy dla różnych postaci lub dostosowuje ton (np. szepcze w momencie napięcia lub śmieje się z żartu), aby dopasować go do narracji.

  • Nauka języków: twórz przewodniki po wymowie, które mogą czytać tekst z określonymi akcentami regionalnymi lub w wolniejszym tempie, aby pomóc uczniom ćwiczyć trudną wymowę.

  • Czytniki treści uwzględniające kontekst: czytaj na głos artykuły, przepisy lub posty na blogu, używając głosu i tonu emocjonalnego, które pasują do treści (np. poważnego tonu w przypadku najnowszych wiadomości lub ciepłego, cierpliwego tonu w przypadku instrukcji gotowania krok po kroku).

Z tego przewodnika dowiesz się, jak generować mowę z tekstu wpisanego przez jednego lub wielu rozmówców oraz jak przesyłać strumieniowo odpowiedź audio.

Przejdź do kodu dla jednego rozmówcy Przejdź do kodu dla wielu rozmówców Przejdź do kodu dla odpowiedzi przesyłanych strumieniowo

Porównanie TTS i Live API

Zarówno modele zamiany tekstu na mowę (TTS), jak i modele Live API to modele generujące mowę o niskim opóźnieniu, które można skonfigurować pod kątem różnych głosów i języków odpowiedzi. Służą jednak do bardzo różnych celów.

  • Generowanie zamiany tekstu na mowę (TTS) to jednokierunkowa interakcja typu żądanie-odpowiedź (tekst na wejściu, dźwięk na wyjściu). Jest on dostosowany do scenariuszy, które wymagają dokładnego odczytania podanego tekstu z precyzyjną kontrolą nad stylem i dźwiękiem, takich jak narracja podcastu, audiobooki czy czytanie artykułów na głos.

  • Generowanie Live API obsługuje dwukierunkowe przesyłanie strumieniowe na potrzeby rozmów głosowych w czasie rzeczywistym (głos na wejściu i wyjściu). Doskonale sprawdza się w dynamicznych kontekstach konwersacyjnych, w których model decyduje o odpowiedniej mowie do zwrócenia. Pamiętaj, że najnowsze modele Live API obsługują też dane wejściowe w postaci filmów i obrazów.

Zanim zaczniesz

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dotyczące tego dostawcy.

Jeśli jeszcze nie korzystasz z Firebase, zapoznaj się z przewodnikiem dla początkujących, który opisuje, jak skonfigurować projekt w Firebase, połączyć aplikację z Firebase, dodać pakiet SDK, zainicjować usługę backendu dla wybranego dostawcy Gemini API i utworzyć instancję GenerativeModel.

Do testowania i ulepszania promptów zalecamy używanie Google AI Studio.

Modele obsługujące tę funkcję

  • gemini-3.1-flash-tts-preview

Generowanie mowy na podstawie tekstu

Możesz wygenerować mowę z podanego tekstu za pomocą modelu TTS Gemini.

Generowanie mowy z jednym rozmówcą

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcy Gemini API, aby na tej stronie wyświetlić treści dotyczące tego dostawcy.

Możesz skonfigurować model tak, aby generował dźwięk za pomocą jednego głosu.

W GenerationConfig podaj te informacje:

Wywołaj generateContent za pomocą prompta tekstowego. Model zwraca nieprzetworzone dane audio PCM w częściach odpowiedzi.

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

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współprogramu. 

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

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki 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);
    }
  }
}

Generowanie mowy z wieloma rozmówcami

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcy Gemini API, aby na tej stronie wyświetlić treści dotyczące tego dostawcy.

Możesz skonfigurować model tak, aby używał różnych głosów dla różnych rozmówców w tekście. Jest to przydatne do generowania dźwięku w dialogach lub rozmowach.

  1. Utwórz obiekt MultiSpeakerVoiceConfig, który mapuje nazwy rozmówców (których użyjesz w prompcie) na konkretne nazwy głosów odpowiedzi (np. Kore).

    Konfiguracja z wieloma głośnikami obsługuje dokładnie 2 głośniki.

  2. W GenerationConfig podaj te informacje:

    • Ustaw responseModalities, aby uwzględnić AUDIO.

    • Skonfiguruj SpeechConfig, podając te informacje:

  3. W prompcie wskaż, kto mówi, używając imion rozmówców jako prefiksów (np. Joe: Hello. Jane: Hi.).

Wywołaj generateContent za pomocą prompta tekstowego. Model zwraca nieprzetworzone dane audio PCM w częściach odpowiedzi.

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

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współprogramu. 

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

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki 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);
    }
  }
}

Odpowiadaj na bieżąco

Zanim wypróbujesz ten przykład, wykonaj czynności opisane w sekcji Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcy Gemini API, aby na tej stronie wyświetlić treści dotyczące tego dostawcy.

Możesz uzyskać szybsze interakcje i mniejsze opóźnienia, przesyłając strumieniowo odpowiedź audio w miarę jej generowania, zamiast czekać na ukończenie całego pliku audio.

Strumieniowe przesyłanie wygenerowanej mowy jest obsługiwane zarówno w przypadku konfiguracji z jednym, jak i wieloma rozmówcami. Jest obsługiwany tylko w przypadku modeli Gemini 3.x TTS.

Aby przesyłać strumieniowo odpowiedź głosową, wywołaj generateContentStream zamiast generateContent i obsługuj fragmenty w miarę ich napływania. Poniższe przykłady pokazują, jak przesyłać strumieniowo odpowiedź jednego rozmówcy:

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

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współprogramu. 

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

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki 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);
    }
}


Sterowanie odpowiedzią głosową za pomocą promptów

Możesz wpływać na ton, tempo i styl generowanej mowy, używając określonych technik promptowania.

W podrozdziałach poniżej dotyczących struktury prompta i tagów audio znajdziesz ogólne wskazówki. Szczegółowe wskazówki znajdziesz w tym przewodniku po promptach.

Struktura prompta

Aby uzyskać najlepsze wyniki, prompt powinien zawierać te elementy:

  • Audio Profile: opisz osobowość, tożsamość i archetyp mówcy (np. A warm, professional narrator).

  • Scene: opisz otoczenie i emocjonalny klimat (np. In a quiet library lub Amidst a noisy crowd).

  • Director's Notes: opisz emocje, tempo, styl i akcent (np. Speak slowly and with mystery).

  • Sample Context: podaj modelowi punkt wyjścia (np. The speaker is greeting a close friend).

  • Transkrypcja: tekst, który ma zostać odczytany. Aby uzyskać najlepsze wyniki, upewnij się, że ton i kontekst tekstu są zgodne z profilem głosu i notatkami reżyserskimi.

Przykładowy 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!

Tagi audio

Możesz wstawiać tagi formatowania bezpośrednio do prompta tekstowego, aby kierować działaniem modelu.

Tagi audio są obsługiwane tylko w przypadku modeli Gemini 3.x TTS.

Często używane tagi:

  • [whispers]: mówić szeptem
  • [laughs]: aby dodać śmiech,
  • [giggles]: aby dodać chichot,
  • [sighs]: aby dodać westchnienie
  • [gasp]: Aby dodać westchnienie
  • [shouting]: krzyczeć
  • [excited]: mówienie z ekscytacją
  • [serious]: Mówić poważnie
  • [sighs whispers]: emocje złożone (możesz łączyć tagi)

Podczas korzystania z tagów audio pamiętaj o tych kwestiach:

  • Brak wyczerpującej listy: nie ma stałej listy obsługiwanych tagów. Możesz eksperymentować z różnymi emocjami i wyrażeniami (np. [bored], [sarcastically], a nawet [like dracula]), aby zobaczyć, jak zmienia się wynik.

  • Prompt tekstowy w języku innym niż angielski: jeśli prompt tekstowy nie jest w języku angielskim, aby uzyskać najlepsze wyniki, nadal używaj tagów audio w języku angielskim.

Przykładowy prompt:

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


Ograniczenia i wymagania

Podczas korzystania z generowania mowy pamiętaj o tych ograniczeniach i wymaganiach:

  • Konfiguracja z wieloma głośnikami obsługuje dokładnie 2 głośniki.

  • Te funkcje są obsługiwane tylko w przypadku modeli Gemini 3.x TTS: strumieniowanie, tagi audio i dodatkowe automatycznie wykrywane języki.

Ograniczenia dotyczące: gemini-3.1-flash-tts-preview

  • Niespójność głosu: dane wyjściowe modelu nie zawsze muszą ściśle odpowiadać wybranemu głosowi, jeśli ton i kontekst prompta nie są zgodne z profilem głosu (np. głęboki męski głos próbujący mówić jak młoda dziewczyna). Upewnij się, że kontekst prompta pasuje do głosu.
  • Dłuższe wyniki: jakość i spójność mowy mogą się pogorszyć w przypadku nagrań dłuższych niż kilka minut. Zalecamy podzielenie długich promptów tekstowych na mniejsze części.
  • Sporadyczne zwracanie tokenów tekstowych: model czasami zwraca tokeny tekstowe zamiast tokenów audio, co powoduje niepowodzenie żądania i błąd 500. Ponieważ dzieje się to losowo w niewielkim odsetku żądań, należy zaimplementować w aplikacji logikę ponawiania prób.
  • Błędne odrzucenia przez klasyfikator: niejasne prompty mogą nie przejść przez klasyfikator syntezy mowy, co może skutkować odrzuceniem żądania (PROHIBITED_CONTENT) lub odczytaniem przez model instrukcji dotyczących stylu na głos. Aby tego uniknąć, użyj ustrukturyzowanego prompta z jasnym wprowadzeniem (np. Audio Profile i Director's Notes) na początku.


Obsługiwane głosy i języki

Modele TTS Gemini przyjmują tekst i generują dane wyjściowe audio, więc odpowiedzią jest sama syntezowana mowa. W poniższych podsekcjach znajdziesz listę obsługiwanych głosów i języków, w których modele TTS Gemini mogą „mówić” (lub odpowiadać).

Głosy są wielojęzyczne, co oznacza, że możesz używać tego samego głosu do generowania mowy w dowolnym z obsługiwanych języków. Możesz na przykład ustawić głos na Kore i wysłać zestaw promptów tekstowych w językach hiszpańskim, hindi i wietnamskim. Odpowiedzi będą udzielane głosem Kore, ale w różnych językach.

Nazwy głosów

Modele zamiany tekstu na mowę Gemini obsługują 30 różnych syntetyzowanych głosów HD, z których każdy ma odrębne cechy. Możesz wyświetlić listę opcji głosu odpowiedzi i posłuchać wersji demonstracyjnych każdego głosu, rozwijając sekcję poniżej.

Języki

Modele TTS Gemini mogą automatycznie wykrywać te języki w prompcie tekstowym. Wygenerowana mowa będzie w tym języku.

Pamiętaj, że w konfiguracji mowy możesz opcjonalnie jawnie ustawić kod języka.

Języki obsługiwane przez wszystkie modele generujące dźwięk
Język Kod BCP-47 Język Kod BCP-47
arabski (egipski) ar-EG niemiecki (Niemcy) de-DE
angielski (USA) en-US hiszpański (USA) es-US
francuski (Francja) fr-FR hindi (Indie) hi-IN
indonezyjski (Indonezja) id-ID włoski (Włochy) it-IT
japoński (Japonia) ja-JP koreański (Korea) ko-KR
portugalski (Brazylia) pt-BR rosyjski (Rosja) ru-RU
niderlandzki (Holandia) nl-NL polski (Polska) pl-PL
tajski (Tajlandia) th-TH turecki (Turcja) tr-TR
wietnamski (Wietnam) vi-VN rumuński (Rumunia) ro-RO
ukraiński (Ukraina) uk-UA bengalski (Bangladesz) bn-BD
angielski (Indie) Pakiet en-IN i hi-IN marathi (Indie) mr-IN
tamilski (Indie) ta-IN telugu (Indie) te-IN
Dodatkowe języki obsługiwane przez modele 3.x generujące dźwięk
Język Kod BCP-47 Język Kod BCP-47
afrikaans af filipiński fil
albański sq fiński fi
amharski am galicyjski gl
ormiański hy gruziński ka
azerski az grecki el
baskijski eu gudżarati gu
białoruski be kreolski haitański ht
bułgarski bg hebrajski he
birmański moje węgierski hu
kataloński urząd certyfikacji islandzki jest
cebuański ceb jawajski jv
chiński (mandaryński) cmn kannada kn
chorwacki godz. konkani kok
czeski cs laotański lo
duński da łaciński la
estoński et łotewski lv
litewski lt luksemburski lb
macedoński mk maithili mai
malgaski mg malajski ms
malajalam ml mongolski mn
nepalski ne norweski (bokmål), nb
norweski (nynorsk) nn orija lub
paszto ps perski fa
pendżabski pa serbski sr
sindhi sd syngaleski si
słowacki sk słoweński sl
suahili sw szwedzki sv
urdu ur

(Opcjonalnie) Jawne ustawianie kodu języka

Jeśli nie określisz kodu języka w konfiguracji mowy, model automatycznie wykryje język w prompcie tekstowym.

Możesz jednak opcjonalnie ustawić język (za pomocą parametru languageCode w konfiguracji mowy). Aby to zrobić, musisz użyć jednego z tych obsługiwanych kodów języka zgodnych ze standardem BCP-47:

  • arabski: ar-XA
  • bengalski: bn-IN
  • chiński (mandaryński): cmn-CN
  • niderlandzki: nl-NL
  • angielski: en-US, en-GB, en-AU, en-IN
  • francuski: fr-FR, fr-CA
  • niemiecki: de-DE
  • gudżarati: gu-IN
  • Hindi: hi-IN
  • indonezyjski: id-ID
  • włoski: it-IT
  • japoński: ja-JP
  • kannada: kn-IN
  • koreański: ko-KR
  • malajalam: ml-IN
  • marathi: mr-IN
  • polski: pl-PL
  • portugalski: pt-BR
  • rosyjski: ru-RU
  • hiszpański: es-US, es-ES
  • tamilski: ta-IN
  • telugu: te-IN
  • Tajski: th-TH
  • turecki: tr-TR
  • Wietnamski: vi-VN


Co jeszcze możesz zrobić?

Wypróbuj inne funkcje

Dowiedz się, jak kontrolować generowanie treści

Możesz też eksperymentować z promptami i konfiguracjami modeli, a nawet uzyskać wygenerowany fragment kodu za pomocą Google AI Studio.

Więcej informacji o obsługiwanych modelach

Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia oraz o ich limitach i cenach.


Prześlij opinię o korzystaniu z usługi Firebase AI Logic