การสร้างการอ่านออกเสียงข้อความ (TTS)

Gemini API สามารถเปลี่ยนอินพุตข้อความเป็นเสียงที่มีผู้พูดคนเดียวหรือหลายคน โดยใช้ความสามารถในการสร้างข้อความเป็นเสียง (TTS) ของ Gemini การสร้างการอ่านออกเสียงข้อความควบคุมได้ ซึ่งหมายความว่าคุณสามารถรวมข้อมูลเมตาของเทิร์นที่มีโครงสร้าง (speech_metadata) และแท็กเสียงแบบอินไลน์เพื่อกำหนดสไตล์ สำเนียง จังหวะ และโทนเสียงของเสียง

ความสามารถของ TTS แตกต่างจากการสร้างคำพูดที่ให้บริการผ่าน Live API ซึ่งออกแบบมาสำหรับเสียงแบบโต้ตอบที่ไม่มีโครงสร้าง รวมถึงอินพุตและเอาต์พุตแบบหลายรูปแบบ แม้ว่า Live API จะทำงานได้ดี ในบริบทการสนทนาแบบไดนามิก แต่ TTS ผ่าน Gemini API ได้รับการปรับแต่งสำหรับสถานการณ์ที่ต้องมีการอ่านข้อความที่แน่นอนพร้อมการควบคุม สไตล์และเสียงอย่างละเอียด เช่น การสร้างพอดแคสต์หรือหนังสือเสียง

คู่มือนี้จะแสดงวิธีสร้างเสียงแบบลำโพงเดียวและหลายลำโพงจากข้อความโดยใช้ Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) และ Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts)

ก่อนเริ่มต้น

ตรวจสอบว่าคุณใช้โมเดล TTS ของ Gemini ที่แสดงอยู่ในส่วนโมเดลที่รองรับ โปรดดูหัวข้อ เมื่อใดควรใช้โมเดลใด เพื่อเลือกโมเดลที่ดีที่สุดสำหรับปริมาณงานของคุณ

คุณอาจพบว่าการทดสอบโมเดล TTS ของ Gemini ใน AI Studio มีประโยชน์ก่อนที่จะเริ่มสร้าง

TTS แบบผู้พูดคนเดียว

หากต้องการแปลงข้อความเป็นเสียงแบบลำโพงเดียวด้วยโมเดล TTS ของ Gemini 3.8 ให้ส่ง ข้อความถอดเสียงตามคำพูดใน parts[].text แนบสไตล์ระดับการพูดใน parts[].speech_metadata และกำหนดค่าเสียงใน speechConfig.voiceConfig คุณสามารถส่งชื่อเสียงที่สร้างไว้ล่วงหน้า, รหัส Extended Voice Library, รหัสการออกแบบเสียงที่กำหนดเอง (voice_...) หรือรหัสการจำลองเสียง (voice_... หรือ voicekey_... แบบไม่เก็บสถานะที่ไม่บังคับ)

ตัวอย่างนี้จะบันทึกเสียงเอาต์พุตจากโมเดลในไฟล์ WAV

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "voice_config": {"voice": "Kore"}
        },
    },
)

data = response.candidates[0].content.parts[0].inline_data.data
with open("out.wav", "wb") as f:
    f.write(data)

import {GoogleGenAI} from '@google/genai';
import * as fs from 'node:fs';

async function main() {
   const ai = new GoogleGenAI({});

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.wav', audioBuffer);
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode > out.wav

TTS แบบหลายผู้พูด

สำหรับบทสนทนาที่มีผู้พูดหลายคน ให้กำหนดค่าลำโพง 2 ตัวใน multiSpeakerVoiceConfig.speakerVoiceConfigs โดยใช้ prebuiltVoiceConfig และ ส่งบทสนทนาแต่ละช่วงเป็น part แยกกันโดยมี speech_metadata ที่ระบุ ทั้ง speaker และ style ระดับช่วงที่เป็นตัวเลือก

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [
            {
                "text": "How's it going today Jane?",
                "speech_metadata": {
                    "speaker": "Joe",
                    "style": "cheerful and friendly",
                },
            },
            {
                "text": "Not too bad, how about you? Ready to test these new voices?",
                "speech_metadata": {
                    "speaker": "Jane",
                    "style": "calm and relaxed",
                },
            },
        ],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "multi_speaker_voice_config": {
                "speaker_voice_configs": [
                    {
                        "speaker": "Joe",
                        "voice_config": {
                            "prebuilt_voice_config": {"voice_name": "Puck"}
                        },
                    },
                    {
                        "speaker": "Jane",
                        "voice_config": {
                            "prebuilt_voice_config": {"voice_name": "Kore"}
                        },
                    },
                ]
            }
        },
    },
)

data = response.candidates[0].content.parts[0].inline_data.data
with open("out.wav", "wb") as f:
    f.write(data)

import {GoogleGenAI} from '@google/genai';
import * as fs from 'node:fs';

async function main() {
   const ai = new GoogleGenAI({});

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [
            {
               text: "How's it going today Jane?",
               speechMetadata: {
                  speaker: 'Joe',
                  style: 'cheerful and friendly',
               },
            },
            {
               text: 'Not too bad, how about you? Ready to test these new voices?',
               speechMetadata: {
                  speaker: 'Jane',
                  style: 'calm and relaxed',
               },
            },
         ],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            multiSpeakerVoiceConfig: {
               speakerVoiceConfigs: [
                  {
                     speaker: 'Joe',
                     voiceConfig: {
                        prebuiltVoiceConfig: { voiceName: 'Puck' },
                     },
                  },
                  {
                     speaker: 'Jane',
                     voiceConfig: {
                        prebuiltVoiceConfig: { voiceName: 'Kore' },
                     },
                  },
               ],
            },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.wav', audioBuffer);
}

await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [
        {
          "text": "How'\''s it going today Jane?",
          "speech_metadata": {
            "speaker": "Joe",
            "style": "cheerful and friendly"
          }
        },
        {
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "speech_metadata": {
            "speaker": "Jane",
            "style": "calm and relaxed"
          }
        }
      ]
    }],
    "generationConfig": {
      "responseModalities": ["AUDIO"],
      "speechConfig": {
        "multiSpeakerVoiceConfig": {
          "speakerVoiceConfigs": [
            {
              "speaker": "Joe",
              "voiceConfig": {
                "prebuiltVoiceConfig": { "voiceName": "Puck" }
              }
            },
            {
              "speaker": "Jane",
              "voiceConfig": {
                "prebuiltVoiceConfig": { "voiceName": "Kore" }
              }
            }
          ]
        }
      }
    }
  }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
      base64 --decode > out.wav

ควบคุมรูปแบบคำพูดด้วยข้อมูลเมตาและแท็ก

TTS ของ Gemini 3.8 จะถือว่าฟิลด์ text เป็นสำเนาที่ตรงตามต้นฉบับอย่างเคร่งครัด หากต้องการ ควบคุมการนำเสนอโดยไม่ต้องอ่านคำแนะนำบนเวที ให้แบ่งคำสั่งตามขอบเขตดังนี้

• การส่งระดับการพูดอย่างต่อเนื่อง (speech_metadata.style): ใส่อารมณ์ สไตล์การพูด น้ำเสียง จังหวะ และระดับเสียงที่ใช้ตลอดการพูด ใน speech_metadata.style (เช่น "style": "whispered urgently", "style": "out of breath" หรือ "style": "warm and enthusiastic")
• เหตุการณ์ ณ จุดใดจุดหนึ่ง (แท็กในบรรทัด): วางเสียงพูดที่ไม่ได้เป็นคำพูดชั่วคราว หรือหยุดชั่วคราวไว้ในข้อความถอดเสียงโดยตรงโดยใช้เครื่องหมายวงเล็บมุม (เช่น "Wait... <short pause> did you hear that? <sigh>" หรือ "Excuse me <cough> as I was saying...")

ดูแนวทางปฏิบัติแนะนำที่ครอบคลุมได้ในคู่มือการใช้พรอมต์

ตัวเลือกเสียง

TTS ของ Gemini 3.8 รองรับ 4 วิธีในการเลือกหรือสร้างเสียง ดังนี้

1. เสียงสตูดิโอที่สร้างไว้ล่วงหน้า: เสียงที่คัดสรรมา 30 เสียงซึ่งแสดงอยู่ในตารางต่อไปนี้
2. คลังเสียงเพิ่มเติม: เสียงเพิ่มเติมอีกหลายร้อยเสียงในภาษา สำเนียง และต้นแบบตัวละครต่างๆ ซึ่งเข้าถึงได้โดยใช้ client.voices.list() (GET /v1beta/voices)
3. การออกแบบเสียง: สร้าง ลักษณะเสียงร้องที่กำหนดเองจากคำอธิบายภาษาธรรมชาติใน Google AI Studio หรือใช้ POST /v1beta/voices (type="prompted" ซึ่งจะแสดงผล รหัส voice_... ที่ถาวรและตัวอย่าง sample_audio WAV ใน CreateVoice และ GetVoice)
4. การจำลองเสียง: จำลองเสียงของผู้พูดจากเสียงอ้างอิงและเสียงที่ได้รับความยินยอมใน Google AI Studio หรือใช้ POST /v1beta/voices (type="replicated", store=True แบบถาวรโดย ค่าเริ่มต้นหรือ store=False แบบไม่เก็บสถานะที่ไม่บังคับ)

ขีดจำกัดและ TTL ของเสียงที่กำหนดเอง

* การขยาย TTL: หน้าต่างการเก็บรักษา 1 ปีจะรีเซ็ตทุกครั้งที่มีการใช้เสียงอย่างต่อเนื่อง (ไม่ว่าจะโดยการสังเคราะห์เสียงพูดด้วยเสียงนั้นหรือใช้เป็นเสียงพื้นฐานสำหรับการรีมิกซ์) ระบบจะลบเสียงที่ไม่มีกิจกรรมเป็นเวลา 1 ปีโดยอัตโนมัติ

เสียงที่สร้างไว้ล่วงหน้า

คลังเสียงและตัวกรองที่ขยาย

นอกเหนือจากเสียงสตูดิโอแนะนำ 30 เสียงในตารางก่อนหน้าแล้ว คลังเสียงเพิ่มเติมยังมีเสียงอีกหลายร้อยเสียงในภาษาต่างๆ สำเนียงในภูมิภาค บุคลิกตัวละคร และโดเมนต่างๆ คุณสามารถเรียกดู กรอง และ ทดลองใช้คลังเสียงทั้งหมดแบบอินเทอร์แอกทีฟใน Google AI Studio หรือค้นหาแบบเป็นโปรแกรมโดยใช้ client.voices.list() (GET /v1beta/voices โดยใช้ google-genai 2.25.0 ขึ้นไป / @google/genai 2.24.0 ขึ้นไป)

ListVoices จะแสดงเสียงที่คุณบันทึกไว้ (เรียงจากใหม่สุดก่อน) ตามด้วย เสียงในแคตตาล็อกที่สร้างไว้ล่วงหน้าซึ่งตรงกับเกณฑ์ตัวกรองของคุณ เมื่อส่งค่าหลายค่า สำหรับตัวกรองรายการ ระบบจะแสดงเสียงที่ตรงกับค่าใดก็ได้ในตัวกรองนั้น (OR) ในขณะที่พารามิเตอร์ตัวกรองที่แตกต่างกันจะรวมกับ AND

from google import genai

client = genai.Client()

# Filter the Voice Library by language, gender, pitch, domain context, and keyword
response = client.voices.list(
    language_code=["en-US", "en-GB"],
    gender=["female"],
    pitch=["medium", "low"],
    contexts=["Audiobook", "Conversational"],
    type_=["prebuilt"],
    search="warm",
    page_size=50,
)

for voice in response.voices or []:
    print(
        f"{voice.id} | {voice.display_name} ({voice.language_code},"
        f" {voice.accent}, {voice.gender}, pitch={voice.pitch}):"
        f" {voice.description}"
    )

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI();

// Filter the Voice Library by language, gender, pitch, domain context, and keyword
const response = await ai.voices.list({
  language_code: ["en-US", "en-GB"],
  gender: ["female"],
  pitch: ["medium", "low"],
  contexts: ["Audiobook", "Conversational"],
  type: ["prebuilt"],
  search: "warm",
  page_size: 50,
});

for (const voice of response.voices ?? []) {
  console.log(
    `${voice.id} | ${voice.display_name} (${voice.language_code}, ${voice.accent}, ${voice.gender}, pitch=${voice.pitch}): ${voice.description}`
  );
}

curl -G "https://generativelanguage.googleapis.com/v1beta/voices" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  --data-urlencode "language_code=en-US" \
  --data-urlencode "language_code=en-GB" \
  --data-urlencode "gender=female" \
  --data-urlencode "pitch=medium" \
  --data-urlencode "context=Audiobook" \
  --data-urlencode "type=prebuilt" \
  --data-urlencode "search=warm" \
  --data-urlencode "page_size=50"

ภาษาที่รองรับ

โมเดล TTS จะตรวจหาภาษาที่ป้อนโดยอัตโนมัติ TTS ของ Gemini 3.8 Flash (gemini-3.8-flash-tts) รองรับกว่า 130 ภาษา และ TTS ของ Gemini 3.8 Flash-Lite (gemini-3.8-flash-lite-tts) รองรับกว่า 100 ภาษา

รุ่นที่รองรับ

ควรใช้โมเดลใดเมื่อใด

โมเดล TTS ของ Gemini 3.8 ทั้ง 2 โมเดลใช้สคีมา API และรูปแบบพรอมต์เดียวกัน ซึ่งช่วยให้คุณสลับไปมาระหว่างโมเดลทั้ง 2 ได้ด้วยการเปลี่ยนพารามิเตอร์เพียงรายการเดียว

• ใช้ Gemini 3.8 Flash TTS (gemini-3.8-flash-tts) เมื่อความเที่ยงตรงของเสียง การแสดงที่ซับซ้อน และการควบคุมการแสดงออกเป็นสิ่งสำคัญอันดับแรก เหมาะอย่างยิ่งสำหรับงานสร้างสรรค์ระดับสตูดิโอ บทสนทนาที่ซับซ้อนซึ่งมีลำโพงหลายตัว แท็กเสียงร้องที่หนักแน่น การออกเสียงที่ยาก สำเนียงประจำภูมิภาคหรือสำเนียงของชนกลุ่มน้อย และคำบรรยายแบบยาว ที่ต้องใช้เสียงที่มั่นคงและมีเสียงรบกวนในห้องที่เสถียร
• ใช้ Gemini 3.8 Flash-Lite TTS (gemini-3.8-flash-lite-tts) เป็นเครื่องมือที่รวดเร็ว คุ้มค่า แทน gemini-3.1-flash-tts-preview โดยได้รับการเพิ่มประสิทธิภาพสำหรับ การผลิตจำนวนมาก การส่งต่อตัวแทนเสียงสนทนา ฟีเจอร์อ่านออกเสียง การจำลองเสียงที่เชื่อถือได้ และเสียงพูดแบบลำโพงเดี่ยวในชีวิตประจำวัน ในภาษาหลักๆ

คำแนะนำในการย้ายข้อมูล

เมื่ออัปเกรดจากโมเดลเวอร์ชันตัวอย่างก่อนหน้า (gemini-3.1-flash-tts-preview หรือ gemini-2.5-pro-preview-tts) เป็น TTS ของ Gemini 3.8 (gemini-3.8-flash-tts หรือ gemini-3.8-flash-lite-tts) โปรดตรวจสอบการเปลี่ยนแปลงที่สำคัญ 5 อย่างต่อไปนี้

1. แยกสไตล์ออกจากข้อความถอดเสียง: ย้ายคำสั่งการแสดง น้ำเสียง การออกเสียง และ การเว้นวรรค (เช่น "whispering", "out of breath" หรือ "speaking slowly") ออกจากข้อความธรรมดาและไปไว้ใน speech_metadata.style text ต้องเป็นสำเนาบทพูดที่ตรงตามคำพูดทุกคำและแท็กเสียงในบรรทัดเท่านั้น
2. ออกแบบลักษณะตัวตนล่วงหน้าด้วยการออกแบบเสียง: แทนที่บล็อกหลายย่อหน้า "Audio Profile" หรือ "Director's Notes" ด้วยเสียงที่กำหนดเองซึ่งสร้างขึ้น ในการออกแบบเสียง จากนั้น ส่งvoice_...รหัสนั้นผ่านคำขอ TTS โดยมีสตริงstyleว่างเปล่าหรือมีสตริงน้อยที่สุด
3. ใช้การสนทนาแบบมีโครงสร้าง: สำหรับการสนทนาที่มีผู้พูดหลายคน ให้ส่ง part หนึ่งรายการต่อรอบของผู้พูดโดยใช้ speech_metadata.speaker แทนการฝังคำนำหน้า Speaker: ... ไว้ในบล็อกข้อความเดียว
4. ใช้วงเล็บปีกกาสำหรับแท็กเสียงร้องในบรรทัด: ใช้วงเล็บปีกกา (<laugh>, <sigh>, <cough>, <breath>, <short pause>) สำหรับเสียงร้องและหยุดชั่วคราวของมนุษย์ ณ จุดใดจุดหนึ่ง หลีกเลี่ยงแท็กเอฟเฟกต์เสียงที่ไม่มีเสียงร้อง (เช่น เสียงปรบมือหรือเสียงทุ้ม)
5. บัญชีสำหรับเอาต์พุต WAV (AUDIO_WAV) เริ่มต้นในคำขอแบบเอกภาคี:gemini-3.1-flash-tts-previewAUDIO_L16 โมเดล TTS ของ Gemini 3.8 จะแสดงเสียง WAV (AUDIO_WAV) ที่สมบูรณ์พร้อมส่วนหัว RIFF (24 kHz, โมโน, 16 บิต PCM) ในคำขอแบบเอกภาคี ดังนี้
   • หากก่อนหน้านี้โค้ดของคุณห่อไบต์ PCM ดิบไว้ในส่วนหัวของ WAV (เช่น ใช้โมดูล wave ของ Python หรือแพ็กเกจ wav ของ Node) ให้นำ ส่วนหัวที่ห่อด้วยตนเองออก แล้วเขียนไบต์เสียงที่ถอดรหัสแล้วลงในไฟล์ .wav โดยตรง
   • หากไปป์ไลน์ที่มีอยู่ต้องใช้เสียง PCM ดิบแบบไม่มีส่วนหัว, mu-law หรือ A-law ให้ตั้งค่า response_format.audio.mime_type เป็น "AUDIO_L16", "AUDIO_MULAW" หรือ "AUDIO_ALAW" อย่างชัดเจน (เช่น {"response_format": {"audio": {"mime_type": "AUDIO_L16"}}} ใน generateContent หรือ {"response_format": {"type": "audio", "mime_type": "audio/l16"}} ใน Interactions API) ดูรูปแบบเอาต์พุตเสียง

คำแนะนำในการเขียนพรอมต์

โมเดล TTS ของ Gemini 3.8 จะถือว่าข้อความอินพุตเป็นข้อความถอดเสียงตามคำพูดอย่างเคร่งครัด ซึ่งต่างจากโมเดลเวอร์ชันตัวอย่างก่อนหน้านี้ที่ฝังคำสั่งบนเวทีไว้ในข้อความธรรมดา TTS ของ Gemini 3.8 จะแยกคำสั่งระดับการพูดที่ต่อเนื่อง (speech_metadata) ออกจากแท็กเสียงพูดในบรรทัด ณ จุดใดจุดหนึ่ง

ฟิลด์รูปแบบเทียบกับแท็กในบรรทัด

แยกคำสั่งประสิทธิภาพตามขอบเขต

• การนำส่งระดับคำพูด (speech_metadata.style): ใส่แอตทริบิวต์การนำส่งที่ต่อเนื่อง เช่น อารมณ์ ความผันแปรของระดับเสียง จังหวะโดยรวม หรือสไตล์การนำส่ง (เช่น "whispering", "out of breath", "muttering" หรือ "sarcastic") ลงใน ฟิลด์ style ของ speech_metadata หากต้องการสร้างตัวละครและ การแสดงที่สม่ำเสมอตลอดการสนทนา ให้ออกแบบบุคลิกภาพล่วงหน้าใน การออกแบบเสียง และใช้ styleสำหรับการปรับแต่งระดับการสนทนาที่ไม่บังคับเท่านั้น
• เหตุการณ์ ณ จุดใดจุดหนึ่ง (แท็กในบรรทัด): ใส่เสียงพูดที่ไม่ได้เป็นคำพูด เสียงหายใจ หรือการหยุดชั่วคราวในบรรทัดภายในข้อความถอดเสียงโดยใช้วงเล็บเหลี่ยม (<cough>, <breath>, <sigh>, <short pause>) ใช้วงเล็บเหลี่ยม (<...>) เพื่อให้ได้คุณภาพเสียงสูงสุด และใช้เสียงพูดของมนุษย์แทนเอฟเฟกต์เสียงที่ไม่มีเสียงพูด

จังหวะการดำเนินเรื่องและการหยุดชั่วคราว

คุณควบคุมจังหวะและความเงียบได้ 3 ระดับความละเอียด ดังนี้

• เครื่องหมายวรรคตอนและจุดไข่ปลา: ใช้คอมมา ขีดกลาง (--) และจุดไข่ปลา (...) เพื่อแสดงการลังเลในการสนทนาที่เป็นธรรมชาติ
• แท็กหยุดชั่วคราวในบรรทัด: แทรก <short pause> หรือ <long pause> ที่จุดที่แน่นอน ในสคริปต์ที่ผู้พูดควรหยุดชั่วคราว text Hold on, let me think... <short pause> Alright, I've got it.
• อัตราการพูดระดับคำ: ตั้งค่า "style": "speaking rapidly" หรือ "style": "speaking slowly" ใน speech_metadata เพื่อควบคุมอัตราการพูด ตลอดทั้งคำ

ทำนองและระดับเสียง

ใช้ speech_metadata.style เพื่อควบคุมการออกเสียง ระดับเสียง และการผันเสียงใน แต่ละช่วง (เช่น "style": "high pitch, cheerful and excited inflection" หรือ "style": "monotone and flat") หากอารมณ์หรือการออกเสียงเปลี่ยนไประหว่างบทสนทนา ให้ แยกสคริปต์ออกเป็นช่วงๆ โดยมีค่า style ที่แตกต่างกันสำหรับแต่ละช่วง

การเน้น

ใช้อักษรตัวพิมพ์ใหญ่กับคำที่เฉพาะเจาะจงในข้อความถอดเสียง ร่วมกับเครื่องหมายวรรคตอนและแท็กเสียงในบรรทัด เพื่อเน้นเสียงอย่างเป็นธรรมชาติในคำสำคัญ

This is a VERY important point!
It was a VERY long day <sigh> ... nobody listens anymore.

เสียงพูดและเสียงที่ไม่ใช่เสียงพูด

วางเสียงร้องของมนุษย์ที่ไม่ใช่คำพูดในบรรทัดโดยใช้วงเล็บมุม (<...>) ที่ จุดที่ควรมีเสียง แท็กเสียงร้องที่แนะนำมีดังนี้

การตอบรับระหว่างการสนทนาและเสียงพูดทับซ้อนกัน

ในการสนทนาที่มีผู้พูดหลายคน ให้ใส่ปฏิกิริยาของผู้ฟังในอักขระไปป์ (|reaction|) ภายในเทิร์นของผู้พูดเพื่อสร้างช่องทางย้อนกลับที่เป็นธรรมชาติหรือ การพูดทับกันโดยไม่ต้องแบ่งเป็นเทิร์นแยกต่างหากต่อรีแอ็กชัน

• การแลกเปลี่ยนข้อความสั้นๆ ในช่องสื่อสารเบื้องหลัง: แทรกรีแอ็กชันสั้นๆ ของผู้ฟัง (|oh hmm|, |oh really?|, |absolutely|) ในช่วงที่ผู้ที่กำลังพูดกำลังพูด
  • เทิร์นที่ 1 (ผู้พูด ก.): "So the launch is Thursday |oh hmm| Are we actually ready?"
  • เทิร์นที่ 2 (ผู้พูด ข): "Ready enough |oh really?| The last blocker cleared this morning."
  • เทิร์นที่ 3 (ผู้พูด ก.): "Then let's ship it |absolutely| and watch the dashboards."
• คำพูดที่ทับซ้อนกันและสลับกัน:ใช้ส่วนไปป์หลายส่วนเพื่อ จำลองคำพูดที่พูดพร้อมกันหรือสลับกันระหว่างผู้พูด 2 คน (ทำงานได้ดีที่สุด กับ gemini-3.8-flash-tts):
  • การนับถอยหลัง/การร้องประสานเสียงพร้อมกัน: "Let's surprise him on three |ok| ready?" ตามด้วย "one. two. three. |happy| happy |birthday| birthday!"
  • เสียงพูดทับกันโดยสมบูรณ์: "Hello |oh| there |my| it |goodness| must |gracious| be |would| almost |you| time |look| for |at that| dinner"

ความสอดคล้องกันในแต่ละรุ่นและสิ่งที่ควรหลีกเลี่ยง

ทำตามหลักเกณฑ์ต่อไปนี้เพื่อให้เสียงพูดมีความสม่ำเสมอในแต่ละรอบ

• ออกแบบเพอร์โซนาตั้งแต่เนิ่นๆ ในการออกแบบเสียงแทนที่จะใช้บล็อกรูปแบบยาว: "Audio Profile" ย่อหน้าแบบยาวและ"Director's Notes" รายการแบบหลายหัวข้อย่อยที่นำมาจากโมเดลก่อนหน้านี้เป็นสาเหตุที่พบบ่อยที่สุดที่ทำให้เสียงเปลี่ยนไป ใช้สัญชาตญาณด้านครีเอทีฟโฆษณาเดียวกันนั้นตั้งแต่ต้นในการออกแบบเสียงเพื่อสร้างvoice_...ลักษณะตัวละครที่กำหนดเองอย่างต่อเนื่อง จากนั้นใช้รหัสเสียงนั้นผ่านการเรียก TTS
• ใช้การอ้างอิงเสียงเพื่อความเสถียร (ละเว้นคำสั่งเมตา): โมเดล TTS ของ Gemini 3.8 ได้รับการฝึกให้ยึดการอ้างอิงเสียงเป็นอันดับแรก อย่าใส่วิธีการที่บอกโมเดลให้คงเสียงไว้ (เช่น "do not switch speaker identity" หรือ "maintain identical timbre") เพราะข้อความพรอมต์เพิ่มเติมจะทำให้เกิดการดริฟต์มากขึ้น ละเว้นคำสั่งสไตล์ที่ไม่จำเป็นและปล่อยให้โมเดล เปลี่ยนแปลงไปตามธรรมชาติรอบจุดที่เสถียรซึ่งอ้างอิงจากเสียง
• อย่าพยายามเปลี่ยนลักษณะของผู้พูดที่เปลี่ยนแปลงไม่ได้ใน style: หลีกเลี่ยงการใส่ อายุ เพศ ชื่อ หรือการเปลี่ยนสำเนียงถาวรใน speech_metadata.style แต่ให้เลือกเสียงในภูมิภาคจากคลังเสียงเพิ่มเติมหรือสร้างเสียงด้วยการออกแบบเสียงแทน

เวิร์กโฟลว์ที่แนะนำ

1. สร้างตัวละครเพียงครั้งเดียว: สร้างตัวละครในการออกแบบเสียง หรือเลือกเสียงในภูมิภาคจากคลังเสียงเพิ่มเติมที่ตรงกับภาษาและลักษณะตัวละครเป้าหมาย
2. เขียนข้อความถอดเสียงที่พูดอย่างเป็นธรรมชาติโดยมีคำพูดที่ไม่ต่อเนื่อง: เพื่อให้เป็นธรรมชาติมากที่สุด ให้เขียนtextเป็นข้อความถอดเสียงที่พูดจริง ซึ่งรวมถึงคำพูดที่ไม่ต่อเนื่องและการลังเลในการสนทนาตามธรรมชาติ (เช่น "Oh uh yeah I think... hm, so that's interesting")
3. ทดสอบ TTS แบบธรรมดาก่อน: สังเคราะห์ข้อความถอดเสียงโดยใช้ฟิลด์ style ที่ว่างเปล่าก่อน เนื่องจากคำขอส่วนใหญ่ไม่จำเป็นต้องมีคำสั่ง style เลย
4. เพิ่มพรอมต์สั้นๆ styleสำหรับการปรับแต่งเท่านั้น: เพิ่มstyleสตริง แบบย่อ (เช่น "casual, friendly" หรือ "muttering, then reassuring") เฉพาะสำหรับ เทิร์นที่ต้องมีการปรับการนำส่งที่เฉพาะเจาะจง และนำสตริงสั้นๆ ที่แน่นอนนั้นกลับมาใช้ซ้ำในเทิร์นต่างๆ เมื่อต้องการใช้ค่าพื้นฐานที่สอดคล้องกัน

ตัวแทนการสนทนาไปมาและเสียงพูดแบบหลายรอบ

เมื่อสร้างเอเจนต์เสียงแบบสนทนาแบบเรียลไทม์หรือแอปพลิเคชันแบบการสนทนาไปมา ให้ทำดังนี้

• เรียกใช้ TTS 1 ครั้งต่อรอบเมื่อได้รับข้อความ LLM
• ปล่อยให้ voice ที่กำหนดค่าไว้ (สร้างไว้ล่วงหน้า ออกแบบ voice_... หรือจำลอง voice_... / voicekey_...) ระบุตัวตนของลำโพงในแต่ละรอบ ไม่ต้องส่งตัวตนของตัวละครที่มีลักษณะยาวอีกในแต่ละรอบ
• ปล่อยช่อง style ต่อรอบว่างไว้ หรือส่งสตริงค่าคงที่แบบสั้น 1 รายการ (เช่น "casual, friendly") สำหรับการสนทนาทั้งหมด
• แบ่งคำตอบของตัวแทนที่ยาวออกเป็นคำตอบที่สั้นลงแทนที่จะใช้ พรอมต์สไตล์ที่เข้มข้นขึ้น

การสร้างคำพูดแบบสตรีมมิง

คุณสามารถสตรีมเสียงที่สร้างขึ้นขณะที่โมเดลกำลังสังเคราะห์เสียง ไม่เหมือนกับคำขอแบบเอกภาค (ซึ่งจะแสดงผลไฟล์ WAV ที่สมบูรณ์พร้อมส่วนหัว RIFF) คำขอการสตรีมจะแสดงผลก้อนข้อมูล PCM เชิงเส้นแบบ 16 บิตที่ลงนามแบบ Little-Endian ดิบที่ไม่มีส่วนหัว (AUDIO_L16 / audio/L16;codec=pcm;rate=24000, 24 kHz, โมโน) โดยค่าเริ่มต้น เพื่อให้เล่นหรือต่อก้อนข้อมูลเสียงได้อย่างต่อเนื่องโดยไม่มีส่วนหัวของคอนเทนเนอร์

from google import genai

client = genai.Client()

response_stream = client.models.generate_content_stream(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "speech_config": {
            "voice_config": {"voice": "Kore"}
        },
    },
)

for chunk in response_stream:
    try:
        data = chunk.candidates[0].content.parts[0].inline_data.data
        # data contains raw PCM bytes (24kHz, 1-channel, 16-bit)
    except (IndexError, AttributeError):
        pass

import {GoogleGenAI} from '@google/genai';

async function main() {
   const ai = new GoogleGenAI({});

   const responseStream = await ai.models.generateContentStream({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   for await (const chunk of responseStream) {
      const data = chunk.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
      if (data) {
         const audioBuffer = Buffer.from(data, 'base64');
         // Process the audio buffer
      }
   }
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:streamGenerateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }'

รูปแบบเอาต์พุตเสียง

โมเดล TTS ของ Gemini 3.8 ใช้รูปแบบเสียงเริ่มต้นที่แตกต่างกัน ขึ้นอยู่กับว่าคำขอเป็นแบบเอกภาคหรือแบบสตรีมมิง ดังนี้

• คำขอแบบเอกภาค (models.generate_content): แสดงผลเสียง WAV (AUDIO_WAV) ที่สมบูรณ์พร้อมส่วนหัว RIFF (24 kHz, โมโน, 16 บิตที่ลงนาม PCM แบบ Little-Endian) คุณเขียนไบต์เสียงที่ถอดรหัสแล้วลงใน.wavไฟล์ได้โดยตรงโดยไม่ต้องเพิ่มคอนเทนเนอร์ WAV ด้วยตนเอง
• คำขอสตรีมมิง (models.generate_content_stream / streamGenerateContent): ส่งคืนก้อนLinear PCM แบบดิบที่ไม่มีส่วนหัว (AUDIO_L16) (24 kHz, โมโน PCM แบบ 16 บิตที่ลงนามแบบ Little-Endian) โดยค่าเริ่มต้นเพื่อให้สตรีมหรือ ต่อก้อนอย่างต่อเนื่องได้โดยไม่ต้องมีส่วนหัวของคอนเทนเนอร์ในแต่ละก้อน

คุณลบล้างการเข้ารหัสเสียงเอาต์พุตและอัตราการสุ่มตัวอย่างได้โดยใช้ generationConfig.responseFormat.audio:

นอกจากนี้ คุณยังระบุ sampleRate (เช่น 24000, 16000 หรือ 8000 Hz โดยค่าเริ่มต้นจะเป็น 24000 Hz) ได้ด้วย

ตัวอย่างต่อไปนี้จะขอ PCM 16 บิตแบบดิบที่ไม่มีส่วนหัว (AUDIO_L16) ที่ 24 kHz

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash-tts",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {"style": "cheerful and friendly"},
        }],
    }],
    config={
        "response_modalities": ["AUDIO"],
        "response_format": {
            "audio": {
                "mime_type": "AUDIO_L16",
                "sample_rate": 24000,
            }
        },
        "speech_config": {
            "voice_config": {"voice": "Kore"}
        },
    },
)

data = response.candidates[0].content.parts[0].inline_data.data
with open("out.pcm", "wb") as f:
    f.write(data)

import {GoogleGenAI} from '@google/genai';
import * as fs from 'node:fs';

async function main() {
   const ai = new GoogleGenAI({});

   const response = await ai.models.generateContent({
      model: 'gemini-3.8-flash-tts',
      contents: [{
         role: 'user',
         parts: [{
            text: 'Have a wonderful day!',
            speechMetadata: { style: 'cheerful and friendly' },
         }],
      }],
      config: {
         responseModalities: ['AUDIO'],
         responseFormat: {
            audio: {
               mimeType: 'AUDIO_L16',
               sampleRate: 24000,
            },
         },
         speechConfig: {
            voiceConfig: { voice: 'Kore' },
         },
      },
   });

   const data = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
   const audioBuffer = Buffer.from(data, 'base64');

   fs.writeFileSync('out.pcm', audioBuffer);
}
await main();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash-tts:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
        "contents": [{
          "role": "user",
          "parts": [{
            "text": "Have a wonderful day!",
            "speech_metadata": {
              "style": "cheerful and friendly"
            }
          }]
        }],
        "generationConfig": {
          "responseModalities": ["AUDIO"],
          "responseFormat": {
            "audio": {
              "mimeType": "AUDIO_L16",
              "sampleRate": 24000
            }
          },
          "speechConfig": {
            "voiceConfig": {
              "voice": "Kore"
            }
          }
        }
    }' | jq -r '.candidates[0].content.parts[0].inlineData.data' | \
          base64 --decode > out.pcm

ข้อจำกัด

• โมเดล TTS รับอินพุตที่เป็นข้อความเท่านั้นและสร้างเอาต์พุตที่เป็นเสียงเท่านั้น
• การสร้างเสียงของผู้พูดหลายคนในคำขอเดียว (multiSpeakerVoiceConfig) รองรับ ผู้พูดสูงสุด 2 คนที่ใช้เสียงที่สร้างไว้ล่วงหน้า หากต้องการรวมเสียงที่ออกแบบเอง (voice_...) หรือจำลอง (voice_... / voicekey_...) ใน บทสนทนาที่มีหลายตัวละคร ให้สังเคราะห์เสียงพูดของแต่ละคนแยกกัน เนื่องจากคำขอแบบเอกภาคจะแสดง audio/wav ที่มีส่วนหัว RIFF ขนาด 44 ไบต์โดยค่าเริ่มต้น ให้ขอ PCM ดิบ (AUDIO_L16) หรือนำส่วนหัว WAV ออกจากแต่ละรอบก่อนที่จะต่อเฟรมเสียง PCM 24kHz
• ขีดจำกัดพื้นที่เก็บข้อมูลเสียงที่กำหนดเองและ TTL:
  • เสียงแบบมีสถานะ (store=True, พรอมต์หรือจำลอง): สูงสุด 200 เสียงต่อโปรเจ็กต์ที่มี TTL 1 ปี (Time to Live)
  • คีย์เสียงแบบไม่เก็บสถานะ (store=False, voicekey_...): TTL 7 วัน (Time to Live)
• ดูส่วนภาษาที่รองรับ เพื่อดูการครอบคลุมภาษา

ขั้นตอนถัดไป

• สร้างตัวตนของเสียงร้องที่กำหนดเองจากภาษาธรรมชาติด้วยการออกแบบเสียง
• จำลองเสียงของวิทยากรที่มีอยู่แล้วในการจำลองเสียง
• เปรียบเทียบข้อกำหนดของโมเดลในหน้าโมเดล Gemini 3.8 Flash TTS และ Gemini 3.8 Flash-Lite TTS
• สำรวจเสียงแบบโต้ตอบ 2 ทิศทางด้วย Live API