在 AI Studio 中試用全新的 Gemini 3.1 Flash Live 音訊轉音訊模型。

Live API capabilities guide

這份完整指南涵蓋 Live API 提供的功能和設定。如需常見用途的總覽和程式碼範例，請參閱「開始使用 Live API」頁面。

事前準備

熟悉核心概念：如果您還沒看過「開始使用 Live API 」頁面，請先閱讀該頁面。本課程將介紹 Live API 的基本原則、運作方式，以及不同的實作方法。
在 AI Studio 中試用 Live API：建議您先在 Google AI Studio 中試用 Live API，再開始建構應用程式。如要在 Google AI Studio 中使用 Live API，請選取「串流」。

模式比較

下表摘要列出 Gemini 3.1 Flash Live Preview 和 Gemini 2.5 Flash Live Preview 模型的主要差異：

功能	Gemini 3.1 Flash Live Preview	Gemini 2.5 Flash Live Preview
思考型	使用 `thinkingLevel` 透過 `minimal`、`low`、`medium` 和 `high` 等設定控制思考深度。預設為 `minimal`，可將延遲降至最低。請參閱思考層級和預算。	使用 `thinkingBudget` 設定思考詞元數量。動態思考功能預設為啟用。將 `thinkingBudget` 設為 `0` 即可停用。請參閱思考層級和預算。
接收回應	單一伺服器事件可同時包含多個內容部分 (例如 `inlineData` 和轉錄稿)。請確保程式碼會處理每個事件中的所有部分，以免遺漏內容。	每個伺服器事件只包含一個內容部分。各部分會以個別事件的形式傳送。
客戶內容	`send_client_content` 僅支援播送初始內容記錄 (需要在工作階段設定中設定 `initial_history_in_client_content`)。如要在對話期間傳送文字更新，請改用 `send_realtime_input`。	`send_client_content` 在整個對話過程中都會受到支援，可傳送增量內容更新和建立背景資訊。
涵蓋範圍	預設為 `TURN_INCLUDES_AUDIO_ACTIVITY_AND_ALL_VIDEO`。模型的回覆內容包括偵測到的音訊活動和所有影片影格。	預設為 `TURN_INCLUDES_ONLY_ACTIVITY`。模型的回覆只會包含偵測到的活動。
自訂 VAD (`activity_start`/`activity_end`)	支援。停用自動 VAD，然後手動傳送 `activityStart` 和 `activityEnd` 訊息，控管回合界線。	支援。停用自動 VAD，然後手動傳送 `activityStart` 和 `activityEnd` 訊息，控管回合界線。
自動 VAD 設定	支援。設定 `start_of_speech_sensitivity`、`end_of_speech_sensitivity`、`prefix_padding_ms` 和 `silence_duration_ms` 等參數。	支援。設定 `start_of_speech_sensitivity`、`end_of_speech_sensitivity`、`prefix_padding_ms` 和 `silence_duration_ms` 等參數。
非同步函式呼叫 (`behavior: NON_BLOCKING`)	不支援。函式呼叫僅支援循序執行。您必須傳送工具回應，模型才會開始回覆。	支援。在函式宣告中將 `behavior` 設為 `NON_BLOCKING`，讓模型在函式執行時繼續互動。使用 `scheduling` 參數 (`INTERRUPT`、`WHEN_IDLE` 或 `SILENT`)，控管模型處理回應的方式。
主動音訊	不支援	支援。啟用後，如果輸入內容不相關，模型可以主動決定不回應。在 `proactivity` 設定中將 `proactive_audio` 設為 `true` (需要 `v1alpha`)。
情緒感知對話	不支援	支援。模型會根據輸入內容的措辭和語氣調整回覆風格。在工作階段設定中將 `enable_affective_dialog` 設為 `true` (需要 `v1alpha`)。

如要從 Gemini 2.5 Flash Live 遷移至 Gemini 3.1 Flash Live，請參閱遷移指南。

建立連線

以下範例說明如何使用 API 金鑰建立連線：

Python

import asyncio
from google import genai

client = genai.Client()

model = "gemini-3.1-flash-live-preview"
config = {"response_modalities": ["AUDIO"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        print("Session started")
        # Send content...

if __name__ == "__main__":
    asyncio.run(main())

JavaScript

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

const ai = new GoogleGenAI({});
const model = 'gemini-3.1-flash-live-preview';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        console.debug(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  console.debug("Session started");
  // Send content...

  session.close();
}

main();

互動模式

以下各節提供範例和相關背景資訊，說明 Live API 支援的各種輸入和輸出模式。

正在傳送音訊

音訊必須以原始 PCM 資料 (原始 16 位元 PCM 音訊、16 kHz、小端序) 傳送。

Python

# Assuming 'chunk' is your raw PCM audio bytes
await session.send_realtime_input(
    audio=types.Blob(
        data=chunk,
        mime_type="audio/pcm;rate=16000"
    )
)

JavaScript

// Assuming 'chunk' is a Buffer of raw PCM audio
session.sendRealtimeInput({
  audio: {
    data: chunk.toString('base64'),
    mimeType: 'audio/pcm;rate=16000'
  }
});

音訊格式

Live API 中的音訊資料一律為原始的小端序 16 位元 PCM。音訊輸出內容一律會使用 24kHz 的取樣率。輸入音訊的原始取樣率為 16 kHz，但 Live API 會視需要重新取樣，因此可以傳送任何取樣率。如要傳達輸入音訊的取樣率，請將每個包含音訊的 Blob 的 MIME 類型設為 audio/pcm;rate=16000 等值。

接收音訊

模型會以資料區塊的形式傳回音訊回覆。

Python

async for response in session.receive():
    if response.server_content and response.server_content.model_turn:
        for part in response.server_content.model_turn.parts:
            if part.inline_data:
                audio_data = part.inline_data.data
                # Process or play the audio data

JavaScript

// Inside the onmessage callback
const content = response.serverContent;
if (content?.modelTurn?.parts) {
  for (const part of content.modelTurn.parts) {
    if (part.inlineData) {
      const audioData = part.inlineData.data;
      // Process or play audioData (base64 encoded string)
    }
  }
}

正在傳送文字內容

您可以使用 send_realtime_input (Python) 或 sendRealtimeInput (JavaScript) 傳送文字。

Python

await session.send_realtime_input(text="Hello, how are you?")

JavaScript

session.sendRealtimeInput({
  text: 'Hello, how are you?'
});

正在傳送影片

系統會以特定影格率 (每秒最多 1 個影格) 傳送影片影格，並以個別圖片 (例如 JPEG 或 PNG) 形式傳送。

Python

# Assuming 'frame' is your JPEG-encoded image bytes
await session.send_realtime_input(
    video=types.Blob(
        data=frame,
        mime_type="image/jpeg"
    )
)

JavaScript

// Assuming 'frame' is a Buffer of JPEG-encoded image data
session.sendRealtimeInput({
  video: {
    data: frame.toString('base64'),
    mimeType: 'image/jpeg'
  }
});

內容增量更新

使用增量更新傳送文字輸入內容、建立工作階段情境或還原工作階段情境。如果是簡短的對話內容，您可以傳送逐輪互動，代表事件的確切順序：

Python

turns = [
    {"role": "user", "parts": [{"text": "What is the capital of France?"}]},
    {"role": "model", "parts": [{"text": "Paris"}]},
]

await session.send_client_content(turns=turns, turn_complete=False)

turns = [{"role": "user", "parts": [{"text": "What is the capital of Germany?"}]}]

await session.send_client_content(turns=turns, turn_complete=True)

JavaScript

let inputTurns = [
  { "role": "user", "parts": [{ "text": "What is the capital of France?" }] },
  { "role": "model", "parts": [{ "text": "Paris" }] },
]

session.sendClientContent({ turns: inputTurns, turnComplete: false })

inputTurns = [{ "role": "user", "parts": [{ "text": "What is the capital of Germany?" }] }]

session.sendClientContent({ turns: inputTurns, turnComplete: true })

如果脈絡較長，建議提供單一訊息摘要，以便在後續互動中釋放脈絡窗口。如要瞭解載入工作階段內容的其他方法，請參閱「繼續工作階段」。

音訊轉錄

除了模型回覆，您也可以取得音訊輸出內容和音訊輸入內容的轉錄稿。

如要啟用模型音訊輸出的轉錄功能，請在設定設定中傳送 output_audio_transcription。系統會根據模型的回覆推斷轉錄語言。

Python

import asyncio
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-3.1-flash-live-preview"

config = {
    "response_modalities": ["AUDIO"],
    "output_audio_transcription": {}
}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        message = "Hello? Gemini are you there?"

        await session.send_client_content(
            turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
        )

        async for response in session.receive():
            if response.server_content.model_turn:
                print("Model turn:", response.server_content.model_turn)
            if response.server_content.output_transcription:
                print("Transcript:", response.server_content.output_transcription.text)

if __name__ == "__main__":
    asyncio.run(main())

JavaScript

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

const ai = new GoogleGenAI({});
const model = 'gemini-3.1-flash-live-preview';

const config = {
  responseModalities: [Modality.AUDIO],
  outputAudioTranscription: {}
};

async function live() {
  const responseQueue = [];

  async function waitMessage() {
    let done = false;
    let message = undefined;
    while (!done) {
      message = responseQueue.shift();
      if (message) {
        done = true;
      } else {
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
    }
    return message;
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        responseQueue.push(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  const inputTurns = 'Hello how are you?';
  session.sendClientContent({ turns: inputTurns });

  const turns = await handleTurn();

  for (const turn of turns) {
    if (turn.serverContent && turn.serverContent.outputTranscription) {
      console.debug('Received output transcription: %s\n', turn.serverContent.outputTranscription.text);
    }
  }

  session.close();
}

async function main() {
  await live().catch((e) => console.error('got error', e));
}

main();

如要啟用模型音訊輸入內容的轉錄功能，請在設定設定中傳送 input_audio_transcription。

Python

import asyncio
from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-3.1-flash-live-preview"

config = {
    "response_modalities": ["AUDIO"],
    "input_audio_transcription": {},
}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        audio_data = Path("16000.pcm").read_bytes()

        await session.send_realtime_input(
            audio=types.Blob(data=audio_data, mime_type='audio/pcm;rate=16000')
        )

        async for msg in session.receive():
            if msg.server_content.input_transcription:
                print('Transcript:', msg.server_content.input_transcription.text)

if __name__ == "__main__":
    asyncio.run(main())

JavaScript

import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";
import pkg from 'wavefile';
const { WaveFile } = pkg;

const ai = new GoogleGenAI({});
const model = 'gemini-3.1-flash-live-preview';

const config = {
  responseModalities: [Modality.AUDIO],
  inputAudioTranscription: {}
};

async function live() {
  const responseQueue = [];

  async function waitMessage() {
    let done = false;
    let message = undefined;
    while (!done) {
      message = responseQueue.shift();
      if (message) {
        done = true;
      } else {
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
    }
    return message;
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        responseQueue.push(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  // Send Audio Chunk
  const fileBuffer = fs.readFileSync("16000.wav");

  // Ensure audio conforms to API requirements (16-bit PCM, 16kHz, mono)
  const wav = new WaveFile();
  wav.fromBuffer(fileBuffer);
  wav.toSampleRate(16000);
  wav.toBitDepth("16");
  const base64Audio = wav.toBase64();

  // If already in correct format, you can use this:
  // const fileBuffer = fs.readFileSync("sample.pcm");
  // const base64Audio = Buffer.from(fileBuffer).toString('base64');

  session.sendRealtimeInput(
    {
      audio: {
        data: base64Audio,
        mimeType: "audio/pcm;rate=16000"
      }
    }
  );

  const turns = await handleTurn();
  for (const turn of turns) {
    if (turn.text) {
      console.debug('Received text: %s\n', turn.text);
    }
    else if (turn.data) {
      console.debug('Received inline data: %s\n', turn.data);
    }
    else if (turn.serverContent && turn.serverContent.inputTranscription) {
      console.debug('Received input transcription: %s\n', turn.serverContent.inputTranscription.text);
    }
  }

  session.close();
}

async function main() {
  await live().catch((e) => console.error('got error', e));
}

main();

變更語音和語言

原生音訊輸出模型支援文字轉語音 (TTS) 模型提供的所有語音。你可以在 AI Studio 中聆聽所有語音。

如要指定語音，請在 speechConfig 物件中設定語音名稱，做為工作階段設定的一部分：

Python

config = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "voice_config": {"prebuilt_voice_config": {"voice_name": "Kore"}}
    },
}

JavaScript

const config = {
  responseModalities: [Modality.AUDIO],
  speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
};

Live API 支援多種語言。原生音訊輸出模型會自動選擇適當的語言，且不支援明確設定語言代碼。

內建音訊功能

最新模型採用原生音訊輸出，可生成自然逼真的語音，並提升多語言效能。

思考中

Gemini 3.1 模型會使用 thinkingLevel 控制思考深度，並提供 minimal、low、medium 和 high 等設定。預設值為 minimal，可將延遲時間降至最低。Gemini 2.5 模型會改用 thinkingBudget 設定思考詞元數量。如要進一步瞭解層級與預算，請參閱「思考層級和預算」。

Python

model = "gemini-3.1-flash-live-preview"

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"]
    thinking_config=types.ThinkingConfig(
        thinking_level="low",
    )
)

async with client.aio.live.connect(model=model, config=config) as session:
    # Send audio input and receive audio

JavaScript

const model = 'gemini-3.1-flash-live-preview';
const config = {
  responseModalities: [Modality.AUDIO],
  thinkingConfig: {
    thinkingLevel: 'low',
  },
};

async function main() {

  const session = await ai.live.connect({
    model: model,
    config: config,
    callbacks: ...,
  });

  // Send audio input and receive audio

  session.close();
}

main();

此外，您可以在設定中將 includeThoughts 設為 true，啟用想法摘要。詳情請參閱想法摘要：

Python

model = "gemini-3.1-flash-live-preview"

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"]
    thinking_config=types.ThinkingConfig(
        thinking_level="low",
        include_thoughts=True
    )
)

JavaScript

const model = 'gemini-3.1-flash-live-preview';
const config = {
  responseModalities: [Modality.AUDIO],
  thinkingConfig: {
    thinkingLevel: 'low',
    includeThoughts: true,
  },
};

情緒感知對話

這項功能可讓 Gemini 根據輸入內容的措辭和語氣調整回覆風格。

如要使用情緒感知對話，請將 API 版本設為 v1alpha，並在設定訊息中將 enable_affective_dialog 設為 true：

Python

client = genai.Client(http_options={"api_version": "v1alpha"})

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    enable_affective_dialog=True
)

JavaScript

const ai = new GoogleGenAI({ httpOptions: {"apiVersion": "v1alpha"} });

const config = {
  responseModalities: [Modality.AUDIO],
  enableAffectiveDialog: true
};

主動式音訊

啟用這項功能後，如果內容不相關，Gemini 可能會主動決定不回覆。

如要使用這項功能，請將 API 版本設為 v1alpha，並在設定訊息中設定 proactivity 欄位，然後將 proactive_audio 設為 true：

Python

client = genai.Client(http_options={"api_version": "v1alpha"})

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    proactivity={'proactive_audio': True}
)

JavaScript

const ai = new GoogleGenAI({ httpOptions: {"apiVersion": "v1alpha"} });

const config = {
  responseModalities: [Modality.AUDIO],
  proactivity: { proactiveAudio: true }
}

語音活動偵測 (VAD)

語音活動偵測 (VAD) 可讓模型辨識使用者何時說話。這對建立自然對話至關重要，因為使用者可以隨時中斷模型。

VAD 偵測到中斷時，系統會取消並捨棄正在進行的生成作業。工作階段記錄只會保留已傳送給用戶端的資訊。接著，伺服器會傳送 BidiGenerateContentServerContent 訊息來回報中斷情形。

Gemini 伺服器隨即會捨棄所有待處理的函式呼叫，並傳送 BidiGenerateContentServerContent 訊息，其中包含已取消呼叫的 ID。

Python

async for response in session.receive():
    if response.server_content.interrupted is True:
        # The generation was interrupted

        # If realtime playback is implemented in your application,
        # you should stop playing audio and clear queued playback here.

JavaScript

const turns = await handleTurn();

for (const turn of turns) {
  if (turn.serverContent && turn.serverContent.interrupted) {
    // The generation was interrupted

    // If realtime playback is implemented in your application,
    // you should stop playing audio and clear queued playback here.
  }
}

自動 VAD

根據預設，模型會對連續音訊輸入串流自動執行 VAD。您可以使用設定配置的 realtimeInputConfig.automaticActivityDetection 欄位設定 VAD。

如果音訊串流暫停超過一秒 (例如使用者關閉麥克風)，就應傳送 audioStreamEnd 事件，清除所有快取的音訊。用戶端隨時可以繼續傳送音訊資料。

Python

# example audio file to try:
# URL = "https://storage.googleapis.com/generativeai-downloads/data/hello_are_you_there.pcm"
# !wget -q $URL -O sample.pcm
import asyncio
from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-3.1-flash-live-preview"

config = {"response_modalities": ["AUDIO"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        audio_bytes = Path("sample.pcm").read_bytes()

        await session.send_realtime_input(
            audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
        )

        # if stream gets paused, send:
        # await session.send_realtime_input(audio_stream_end=True)

        async for response in session.receive():
            if response.text is not None:
                print(response.text)

if __name__ == "__main__":
    asyncio.run(main())

JavaScript

// example audio file to try:
// URL = "https://storage.googleapis.com/generativeai-downloads/data/hello_are_you_there.pcm"
// !wget -q $URL -O sample.pcm
import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";

const ai = new GoogleGenAI({});
const model = 'gemini-3.1-flash-live-preview';
const config = { responseModalities: [Modality.AUDIO] };

async function live() {
  const responseQueue = [];

  async function waitMessage() {
    let done = false;
    let message = undefined;
    while (!done) {
      message = responseQueue.shift();
      if (message) {
        done = true;
      } else {
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
    }
    return message;
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        responseQueue.push(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  // Send Audio Chunk
  const fileBuffer = fs.readFileSync("sample.pcm");
  const base64Audio = Buffer.from(fileBuffer).toString('base64');

  session.sendRealtimeInput(
    {
      audio: {
        data: base64Audio,
        mimeType: "audio/pcm;rate=16000"
      }
    }

  );

  // if stream gets paused, send:
  // session.sendRealtimeInput({ audioStreamEnd: true })

  const turns = await handleTurn();
  for (const turn of turns) {
    if (turn.text) {
      console.debug('Received text: %s\n', turn.text);
    }
    else if (turn.data) {
      console.debug('Received inline data: %s\n', turn.data);
    }
  }

  session.close();
}

async function main() {
  await live().catch((e) => console.error('got error', e));
}

main();

使用 send_realtime_input 時，API 會根據 VAD 自動回應音訊。send_client_content 會依序將訊息新增至模型內容，而 send_realtime_input 則會犧牲確定性排序，以提升回應速度。

自動 VAD 設定

如要進一步控管 VAD 活動，可以設定下列參數。詳情請參閱 API 參考資料。

Python

from google.genai import types

config = {
    "response_modalities": ["AUDIO"],
    "realtime_input_config": {
        "automatic_activity_detection": {
            "disabled": False, # default
            "start_of_speech_sensitivity": types.StartSensitivity.START_SENSITIVITY_LOW,
            "end_of_speech_sensitivity": types.EndSensitivity.END_SENSITIVITY_LOW,
            "prefix_padding_ms": 20,
            "silence_duration_ms": 100,
        }
    }
}

JavaScript

import { GoogleGenAI, Modality, StartSensitivity, EndSensitivity } from '@google/genai';

const config = {
  responseModalities: [Modality.AUDIO],
  realtimeInputConfig: {
    automaticActivityDetection: {
      disabled: false, // default
      startOfSpeechSensitivity: StartSensitivity.START_SENSITIVITY_LOW,
      endOfSpeechSensitivity: EndSensitivity.END_SENSITIVITY_LOW,
      prefixPaddingMs: 20,
      silenceDurationMs: 100,
    }
  }
};

停用自動 VAD

或者，您也可以在設定訊息中將 realtimeInputConfig.automaticActivityDetection.disabled 設為 true，停用自動 VAD。在此設定中，用戶端負責偵測使用者語音，並在適當時間傳送 activityStart 和 activityEnd 訊息。這個設定未傳送 audioStreamEnd。而是以 activityEnd 訊息標示串流中斷。

Python

config = {
    "response_modalities": ["AUDIO"],
    "realtime_input_config": {"automatic_activity_detection": {"disabled": True}},
}

async with client.aio.live.connect(model=model, config=config) as session:
    # ...
    await session.send_realtime_input(activity_start=types.ActivityStart())
    await session.send_realtime_input(
        audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
    )
    await session.send_realtime_input(activity_end=types.ActivityEnd())
    # ...

JavaScript

const config = {
  responseModalities: [Modality.AUDIO],
  realtimeInputConfig: {
    automaticActivityDetection: {
      disabled: true,
    }
  }
};

session.sendRealtimeInput({ activityStart: {} })

session.sendRealtimeInput(
  {
    audio: {
      data: base64Audio,
      mimeType: "audio/pcm;rate=16000"
    }
  }

);

session.sendRealtimeInput({ activityEnd: {} })

符記數量

您可以在傳回伺服器訊息的 usageMetadata 欄位中，查看使用的權杖總數。

Python

async for message in session.receive():
    # The server will periodically send messages that include UsageMetadata.
    if message.usage_metadata:
        usage = message.usage_metadata
        print(
            f"Used {usage.total_token_count} tokens in total. Response token breakdown:"
        )
        for detail in usage.response_tokens_details:
            match detail:
                case types.ModalityTokenCount(modality=modality, token_count=count):
                    print(f"{modality}: {count}")

JavaScript

const turns = await handleTurn();

for (const turn of turns) {
  if (turn.usageMetadata) {
    console.debug('Used %s tokens in total. Response token breakdown:\n', turn.usageMetadata.totalTokenCount);

    for (const detail of turn.usageMetadata.responseTokensDetails) {
      console.debug('%s\n', detail);
    }
  }
}

媒體解析度

您可以設定工作階段設定中的 mediaResolution 欄位，指定輸入媒體的媒體解析度：

Python

from google.genai import types

config = {
    "response_modalities": ["AUDIO"],
    "media_resolution": types.MediaResolution.MEDIA_RESOLUTION_LOW,
}

JavaScript

import { GoogleGenAI, Modality, MediaResolution } from '@google/genai';

const config = {
    responseModalities: [Modality.AUDIO],
    mediaResolution: MediaResolution.MEDIA_RESOLUTION_LOW,
};

限制

規劃專案時，請注意 Live API 的下列限制。

回覆方式

原生音訊模型僅支援 `AUDIO` 回覆模態。如要取得文字格式的模型回覆，請使用輸出音訊轉錄功能。

用戶端驗證

Live API 預設只提供伺服器對伺服器驗證。如果您使用用戶端對伺服器方法實作 Live API 應用程式，請務必使用暫時性權杖，降低安全風險。

工作階段持續時間

僅限音訊的課程最多 15 分鐘，音訊加視訊的課程最多 2 分鐘。不過，您可以設定不同的工作階段管理技術，無限延長工作階段持續時間。

脈絡窗口

工作階段的脈絡窗口限制如下：

原生音訊輸出模型為 128,000 個符記
其他 Live API 模型為 32,000 個權杖

支援的語言

Live API 支援下列 97 種語言。

語言	BCP-47 代碼	語言	BCP-47 代碼
南非荷蘭文	`af`	拉脫維亞文	`lv`
阿肯文	`ak`	立陶宛文	`lt`
阿爾巴尼亞文	`sq`	馬其頓文	`mk`
阿姆哈拉文	`am`	馬來文	`ms`
阿拉伯文	`ar`	馬拉雅拉姆文	`ml`
亞美尼亞文	`hy`	馬爾他文	`mt`
阿薩姆文	`as`	毛利文	`mi`
亞塞拜然文	`az`	馬拉地文	`mr`
巴斯克文	`eu`	蒙古文	`mn`
白俄羅斯語	`be`	尼泊爾文	`ne`
孟加拉文	`bn`	挪威文	`no`
波士尼亞文	`bs`	歐利亞文	`or`
保加利亞文	`bg`	奧羅莫文	`om`
緬甸文	`my`	普什圖文	`ps`
加泰隆尼亞文	`ca`	波斯文	`fa`
宿霧文	`ceb`	波蘭文	`pl`
中文	`zh`	葡萄牙文	`pt`
克羅埃西亞文	`hr`	旁遮普文	`pa`
捷克文	`cs`	克丘亞文	`qu`
丹麥文	`da`	羅馬尼亞文	`ro`
荷蘭文	`nl`	羅曼斯文	`rm`
英文	`en`	俄文	`ru`
愛沙尼亞文	`et`	塞爾維亞文	`sr`
法羅文	`fo`	信德文	`sd`
菲律賓文	`fil`	錫蘭文	`si`
芬蘭文	`fi`	斯洛伐克文	`sk`
法文	`fr`	斯洛維尼亞文	`sl`
加里西亞文	`gl`	索馬里文	`so`
喬治亞文	`ka`	席索托文	`st`
德文	`de`	西班牙文	`es`
希臘文	`el`	史瓦西里文	`sw`
古吉拉特文	`gu`	瑞典文	`sv`
豪薩文	`ha`	塔吉克文	`tg`
希伯來文	`iw`	泰米爾文	`ta`
北印度文	`hi`	泰盧固文	`te`
匈牙利文	`hu`	泰文	`th`
冰島文	`is`	茨瓦納文	`tn`
印尼文	`id`	土耳其文	`tr`
愛爾蘭文	`ga`	土庫曼語	`tk`
義大利文	`it`	烏克蘭文	`uk`
日文	`ja`	烏都文	`ur`
卡納達文	`kn`	烏茲別克文	`uz`
哈薩克文	`kk`	越南文	`vi`
高棉文	`km`	威爾斯文	`cy`
盧旺達文	`rw`	西弗里西亞文	`fy`
韓文	`ko`	沃洛夫文	`wo`
庫德文	`ku`	約魯巴文	`yo`
吉爾吉斯文	`ky`	祖魯文	`zu`
寮文	`lo`

後續步驟

請參閱「工具使用」和「工作階段管理」指南，瞭解如何有效使用 Live API 的重要資訊。
在 Google AI Studio 試用 Live API。
如要進一步瞭解 Live API 模型，請參閱「模型」頁面上的 Gemini 2.5 Flash Native Audio。
如需更多範例，請參閱 Live API 教戰手冊、Live API 工具教戰手冊和 Live API 入門指令碼。