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 プレビュー版モデルと Gemini 2.5 Flash Live プレビュー版モデルの主な違いをまとめます。

機能	Gemini 3.1 Flash ライブプレビュー	Gemini 2.5 Flash ライブプレビュー
思考モード	`thinkingLevel` を使用して、`minimal`、`low`、`medium`、`high` などの設定で思考の深さを制御します。デフォルトは `minimal` で、レイテンシを最小限に抑えるように最適化されます。思考レベルと予算をご覧ください。	`thinkingBudget` を使用して思考トークンの数を設定します。動的な思考はデフォルトで有効になっています。無効にするには、`thinkingBudget` を `0` に設定します。思考レベルと予算をご覧ください。
レスポンスの受信	1 つのサーバーイベントに複数のコンテンツ部分（`inlineData` や文字起こしなど）を同時に含めることができます。コンテンツの欠落を防ぐため、コードが各イベントのすべての部分を処理するようにしてください。	各サーバーイベントにはコンテンツ部分が 1 つだけ含まれます。パーツは個別のイベントで配信されます。
クライアントコンテンツ	`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 で使用可能なさまざまな入出力モダリティの例とコンテキストについて説明します。

音声を送信する

音声は RAW PCM データ（RAW 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 の音声データは常に RAW、リトルエンディアン、16 ビット PCM です。オーディオ出力は常に 24 kHz のサンプルレートを使用します。入力音声はネイティブで 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 })

コンテキストが長い場合は、1 つのメッセージの概要を提供して、後続のインタラクション用にコンテキストウィンドウを空けておくことをおすすめします。セッションコンテキストを読み込む別の方法については、セッションの再開をご覧ください。

音声文字起こし

モデルのレスポンスに加えて、オーディオ出力と音声入力の両方の文字起こしを受け取ることもできます。

モデルのオーディオ出力の文字起こしを有効にするには、セットアップ構成で 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 サーバーは保留中の関数呼び出しを破棄し、キャンセルされた呼び出しの ID を記載した BidiGenerateContentServerContent メッセージを送信します。

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 を自動的に実行します。VAD は、セットアップ構成の realtimeInputConfig.automaticActivityDetection フィールドで構成できます。

音声ストリームが 1 秒以上一時停止すると（たとえば、ユーザーがマイクをオフにした場合）、キャッシュに保存された音声をフラッシュするために 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 ネイティブ音声をご覧ください。
Live API クックブック、Live API Tools クックブック、Live API スタートガイドスクリプトで、他の例をお試しください。

Live API capabilities guide

始める前に

モデル比較

接続を確立する

Python

JavaScript

インタラクション モダリティ

音声を送信する

Python

JavaScript

オーディオ形式

音声を受信する

Python

JavaScript

テキストを送信しています

Python

JavaScript

動画を送信しています

Python

JavaScript

コンテンツの増分更新

Python

JavaScript

音声文字起こし

Python

JavaScript

Python

JavaScript

音声と言語を変更する

Python

JavaScript

ネイティブ オーディオ機能

思考モード

Python

JavaScript

Python

JavaScript

アフェクティブ ダイアログ

Python

JavaScript

コンテキストに応じた音声にのみ対応

Python

JavaScript

音声アクティビティ検出（VAD）

Python

JavaScript

自動 VAD

Python

JavaScript

VAD の自動構成

Python

JavaScript

自動 VAD を無効にする

Python

JavaScript

トークン数

Python

JavaScript

メディアの解像度

Python

JavaScript

制限事項

レスポンス モダリティ

クライアント認証

セッション継続時間

コンテキスト ウィンドウ

サポートされている言語

次のステップ

インタラクションモダリティ

ネイティブオーディオ機能

アフェクティブダイアログ

レスポンスモダリティ

コンテキストウィンドウ