Live API capabilities guide

এটি একটি ব্যাপক নির্দেশিকা যা লাইভ API-এর সাথে উপলব্ধ ক্ষমতা এবং কনফিগারেশনগুলিকে কভার করে৷ সাধারণ ব্যবহারের ক্ষেত্রে একটি ওভারভিউ এবং নমুনা কোডের জন্য লাইভ API পৃষ্ঠা দিয়ে শুরু করুন দেখুন।

আপনি শুরু করার আগে

  • মূল ধারণাগুলির সাথে নিজেকে পরিচিত করুন: আপনি যদি ইতিমধ্যে এটি না করে থাকেন তবে প্রথমে লাইভ API এর সাথে শুরু করুন পৃষ্ঠাটি পড়ুন৷ এটি আপনাকে লাইভ API-এর মৌলিক নীতিগুলির সাথে পরিচয় করিয়ে দেবে, এটি কীভাবে কাজ করে এবং বিভিন্ন মডেল এবং তাদের সংশ্লিষ্ট অডিও প্রজন্মের পদ্ধতিগুলির মধ্যে পার্থক্য ( নেটিভ অডিও বা অর্ধ-ক্যাসকেড)।
  • এআই স্টুডিওতে লাইভ এপিআই ব্যবহার করে দেখুন: আপনি বিল্ডিং শুরু করার আগে গুগল এআই স্টুডিওতে লাইভ এপিআই ব্যবহার করে দেখতে পারেন। Google AI স্টুডিওতে লাইভ API ব্যবহার করতে, স্ট্রিম নির্বাচন করুন।

একটি সংযোগ স্থাপন

নিম্নলিখিত উদাহরণ দেখায় কিভাবে একটি API কী দিয়ে একটি সংযোগ তৈরি করতে হয়:

পাইথন

import asyncio
from google import genai

client = genai.Client()

model = "gemini-live-2.5-flash-preview"
config = {"response_modalities": ["TEXT"]}

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

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

জাভাস্ক্রিপ্ট

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

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

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,
  });

  // Send content...

  session.close();
}

main();

মিথস্ক্রিয়া পদ্ধতি

নিম্নলিখিত বিভাগগুলি লাইভ এপিআই-তে উপলব্ধ বিভিন্ন ইনপুট এবং আউটপুট পদ্ধতিগুলির জন্য উদাহরণ এবং সমর্থনকারী প্রসঙ্গ প্রদান করে।

টেক্সট পাঠানো এবং গ্রহণ

আপনি কীভাবে পাঠ্য পাঠাতে এবং গ্রহণ করতে পারেন তা এখানে:

পাইথন

import asyncio
from google import genai

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        message = "Hello, how are you?"
        await session.send_client_content(
            turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
        )

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

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

জাভাস্ক্রিপ্ট

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

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

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.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();

ইনক্রিমেন্টাল কন্টেন্ট আপডেট

টেক্সট ইনপুট পাঠাতে, সেশন প্রসঙ্গ স্থাপন বা সেশন প্রসঙ্গ পুনরুদ্ধার করতে ক্রমবর্ধমান আপডেট ব্যবহার করুন। সংক্ষিপ্ত প্রসঙ্গের জন্য আপনি ঘটনার সঠিক ক্রম উপস্থাপন করতে পালাক্রমে মিথস্ক্রিয়া পাঠাতে পারেন:

পাইথন

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)

জাভাস্ক্রিপ্ট

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 })

দীর্ঘ প্রসঙ্গগুলির জন্য পরবর্তী মিথস্ক্রিয়াগুলির জন্য প্রসঙ্গ উইন্ডোটি মুক্ত করতে একটি একক বার্তা সারাংশ প্রদান করার পরামর্শ দেওয়া হয়। সেশন প্রসঙ্গ লোড করার জন্য অন্য পদ্ধতির জন্য সেশন পুনঃসূচনা দেখুন।

পাঠানো এবং অডিও গ্রহণ

সবচেয়ে সাধারণ অডিও উদাহরণ, অডিও-টু-অডিও , শুরু করা নির্দেশিকাতে কভার করা হয়েছে।

এখানে একটি অডিও-টু-টেক্সট উদাহরণ রয়েছে যা একটি WAV ফাইল পড়ে, এটি সঠিক বিন্যাসে পাঠায় এবং পাঠ্য আউটপুট গ্রহণ করে:

পাইথন

# Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
# Install helpers for converting files: pip install librosa soundfile
import asyncio
import io
from pathlib import Path
from google import genai
from google.genai import types
import soundfile as sf
import librosa

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:

        buffer = io.BytesIO()
        y, sr = librosa.load("sample.wav", sr=16000)
        sf.write(buffer, y, sr, format='RAW', subtype='PCM_16')
        buffer.seek(0)
        audio_bytes = buffer.read()

        # If already in correct format, you can use this:
        # audio_bytes = Path("sample.pcm").read_bytes()

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

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

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

জাভাস্ক্রিপ্ট

// Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
// Install helpers for converting files: npm install wavefile
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-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

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.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);
    }
  }

  session.close();
}

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

main();

এবং এখানে একটি পাঠ্য থেকে অডিও উদাহরণ. আপনি AUDIO রেসপন্স মোডালিটি হিসেবে সেট করে অডিও পেতে পারেন। এই উদাহরণটি WAV ফাইল হিসাবে প্রাপ্ত ডেটা সংরক্ষণ করে:

পাইথন

import asyncio
import wave
from google import genai

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        wf = wave.open("audio.wav", "wb")
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(24000)

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

        async for response in session.receive():
            if response.data is not None:
                wf.writeframes(response.data)

            # Un-comment this code to print audio data info
            # if response.server_content.model_turn is not None:
            #      print(response.server_content.model_turn.parts[0].inline_data.mime_type)

        wf.close()

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

জাভাস্ক্রিপ্ট

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-live-2.5-flash-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,
  });

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

  const turns = await handleTurn();

  // Combine audio data strings and save as wave file
  const combinedAudio = turns.reduce((acc, turn) => {
    if (turn.data) {
      const buffer = Buffer.from(turn.data, 'base64');
      const intArray = new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Int16Array.BYTES_PER_ELEMENT);
      return acc.concat(Array.from(intArray));
    }
    return acc;
  }, []);

  const audioBuffer = new Int16Array(combinedAudio);

  const wf = new WaveFile();
  wf.fromScratch(1, 24000, '16', audioBuffer);
  fs.writeFileSync('output.wav', wf.toBuffer());

  session.close();
}

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

main();

অডিও ফরম্যাট

লাইভ API-এ অডিও ডেটা সবসময় কাঁচা, সামান্য-এন্ডিয়ান, 16-বিট পিসিএম। অডিও আউটপুট সর্বদা 24kHz নমুনা হার ব্যবহার করে। ইনপুট অডিও নেটিভভাবে 16kHz, কিন্তু প্রয়োজন হলে লাইভ API পুনরায় নমুনা তৈরি করবে যাতে যেকোন নমুনা হার পাঠানো যায়। ইনপুট অডিওর নমুনা হার জানাতে, প্রতিটি অডিও-ধারণকারী ব্লবের MIME প্রকারকে audio/pcm;rate=16000 এর মতো একটি মান সেট করুন।

অডিও ট্রান্সক্রিপশন

আপনি সেটআপ কনফিগারেশনে output_audio_transcription পাঠিয়ে মডেলের অডিও আউটপুটের ট্রান্সক্রিপশন সক্ষম করতে পারেন। প্রতিলিপি ভাষা মডেলের প্রতিক্রিয়া থেকে অনুমান করা হয়.

পাইথন

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

client = genai.Client()
model = "gemini-live-2.5-flash-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())

জাভাস্ক্রিপ্ট

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

const ai = new GoogleGenAI({});
const model = 'gemini-live-2.5-flash-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 পাঠিয়ে অডিও ইনপুটের ট্রান্সক্রিপশন সক্ষম করতে পারেন।

পাইথন

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

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

config = {
    "response_modalities": ["TEXT"],
    "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())

জাভাস্ক্রিপ্ট

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-live-2.5-flash-preview';

const config = {
  responseModalities: [Modality.TEXT],
  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.serverContent && turn.serverContent.outputTranscription) {
      console.log("Transcription")
      console.log(turn.serverContent.outputTranscription.text);
    }
  }
  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();

অডিও এবং ভিডিও স্ট্রিম করুন

ভয়েস এবং ভাষা পরিবর্তন করুন

লাইভ এপিআই মডেল প্রতিটি আলাদা আলাদা কণ্ঠস্বর সমর্থন করে। অর্ধ-ক্যাসকেড Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus এবং Zephyr সমর্থন করে। নেটিভ অডিও অনেক লম্বা তালিকা সমর্থন করে ( টিটিএস মডেল তালিকার অনুরূপ)। আপনি এআই স্টুডিওতে সমস্ত ভয়েস শুনতে পারেন।

একটি ভয়েস নির্দিষ্ট করতে, সেশন কনফিগারেশনের অংশ হিসাবে speechConfig অবজেক্টের মধ্যে ভয়েস নাম সেট করুন:

পাইথন

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

জাভাস্ক্রিপ্ট

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

লাইভ API একাধিক ভাষা সমর্থন করে।

ভাষা পরিবর্তন করতে, সেশন কনফিগারেশনের অংশ হিসাবে speechConfig অবজেক্টের মধ্যে ভাষা কোড সেট করুন:

পাইথন

config = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "language_code": "de-DE"
    }
}

জাভাস্ক্রিপ্ট

const config = {
  responseModalities: [Modality.AUDIO],
  speechConfig: { languageCode: "de-DE" }
};

নেটিভ অডিও ক্ষমতা

নিম্নলিখিত ক্ষমতা শুধুমাত্র নেটিভ অডিও সঙ্গে উপলব্ধ. আপনি একটি মডেল এবং অডিও প্রজন্ম চয়ন করুন- এ নেটিভ অডিও সম্পর্কে আরও শিখতে পারেন৷

কিভাবে নেটিভ অডিও আউটপুট ব্যবহার করবেন

নেটিভ অডিও আউটপুট ব্যবহার করতে, একটি নেটিভ অডিও মডেল কনফিগার করুন এবং AUDIO তে response_modalities সেট করুন।

একটি সম্পূর্ণ উদাহরণের জন্য অডিও পাঠান এবং গ্রহণ দেখুন।

পাইথন

model = "gemini-2.5-flash-preview-native-audio-dialog"
config = types.LiveConnectConfig(response_modalities=["AUDIO"])

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

জাভাস্ক্রিপ্ট

const model = 'gemini-2.5-flash-preview-native-audio-dialog';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

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

  // Send audio input and receive audio

  session.close();
}

main();

কার্যকরী সংলাপ

এই বৈশিষ্ট্যটি জেমিনিকে তার প্রতিক্রিয়া শৈলীকে ইনপুট অভিব্যক্তি এবং টোনের সাথে মানিয়ে নিতে দেয়৷

ইফেক্টিভ ডায়ালগ ব্যবহার করতে, এপিআই সংস্করণটিকে v1alpha এ সেট করুন এবং সেটআপ বার্তায় enable_affective_dialog কে true সেট করুন:

পাইথন

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

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

জাভাস্ক্রিপ্ট

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

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

মনে রাখবেন যে ইফেক্টিভ ডায়ালগ বর্তমানে শুধুমাত্র নেটিভ অডিও আউটপুট মডেল দ্বারা সমর্থিত।

সক্রিয় অডিও

যখন এই বৈশিষ্ট্যটি সক্ষম করা থাকে, তখন বিষয়বস্তু প্রাসঙ্গিক না হলে জেমিনি সক্রিয়ভাবে প্রতিক্রিয়া না দেওয়ার সিদ্ধান্ত নিতে পারে।

এটি ব্যবহার করতে, এপিআই সংস্করণটিকে v1alpha এ সেট করুন এবং সেটআপ বার্তায় proactivity ক্ষেত্রটি কনফিগার করুন এবং proactive_audio কে true সেট করুন:

পাইথন

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

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

জাভাস্ক্রিপ্ট

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

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

নোট করুন যে সক্রিয় অডিও বর্তমানে শুধুমাত্র নেটিভ অডিও আউটপুট মডেল দ্বারা সমর্থিত।

চিন্তা সঙ্গে নেটিভ অডিও আউটপুট

নেটিভ অডিও আউটপুট চিন্তা করার ক্ষমতাকে সমর্থন করে, একটি পৃথক মডেল gemini-2.5-flash-exp-native-audio-thinking-dialog মাধ্যমে উপলব্ধ।

একটি সম্পূর্ণ উদাহরণের জন্য অডিও পাঠান এবং গ্রহণ দেখুন।

পাইথন

model = "gemini-2.5-flash-exp-native-audio-thinking-dialog"
config = types.LiveConnectConfig(response_modalities=["AUDIO"])

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

জাভাস্ক্রিপ্ট

const model = 'gemini-2.5-flash-exp-native-audio-thinking-dialog';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

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

  // Send audio input and receive audio

  session.close();
}

main();

ভয়েস অ্যাক্টিভিটি ডিটেকশন (VAD)

ভয়েস অ্যাক্টিভিটি ডিটেকশন (VAD) একজন ব্যক্তি যখন কথা বলছে তখন মডেলটিকে চিনতে দেয়। প্রাকৃতিক কথোপকথন তৈরি করার জন্য এটি অপরিহার্য, কারণ এটি ব্যবহারকারীকে যে কোনো সময় মডেলটিকে বাধা দিতে দেয়।

যখন VAD একটি বাধা শনাক্ত করে, তখন চলমান প্রজন্ম বাতিল এবং বাতিল করা হয়। শুধুমাত্র ক্লায়েন্টকে ইতিমধ্যে পাঠানো তথ্য সেশন ইতিহাসে রাখা হয়। সার্ভার তখন BidiGenerateContentServerContent কনটেন্ট বার্তা পাঠায় বিঘ্নের রিপোর্ট করতে।

জেমিনি সার্ভার তখন যেকোন মুলতুবি থাকা ফাংশন কল বাতিল করে এবং বাতিল করা কলগুলির আইডি সহ একটি BidiGenerateContentServerContent বার্তা পাঠায়।

পাইথন

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.

জাভাস্ক্রিপ্ট

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 ক্ষেত্রের সাথে কনফিগার করা যেতে পারে।

যখন অডিও স্ট্রীমটি এক সেকেন্ডের বেশি সময়ের জন্য বিরাম দেওয়া হয় (উদাহরণস্বরূপ, কারণ ব্যবহারকারী মাইক্রোফোনটি বন্ধ করে দিয়েছে), তখন কোনও ক্যাশে করা অডিও ফ্লাশ করার জন্য একটি audioStreamEnd ইভেন্ট পাঠানো উচিত। ক্লায়েন্ট যেকোনো সময় অডিও ডেটা পাঠানো আবার শুরু করতে পারে।

পাইথন

# 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-live-2.5-flash-preview"

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

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())

জাভাস্ক্রিপ্ট

// 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-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

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 রেফারেন্স দেখুন।

পাইথন

from google.genai import types

config = {
    "response_modalities": ["TEXT"],
    "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,
        }
    }
}

জাভাস্ক্রিপ্ট

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

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

স্বয়ংক্রিয় VAD অক্ষম করুন

বিকল্পভাবে, সেটআপ মেসেজে realtimeInputConfig.automaticActivityDetection.disabled সেট করে স্বয়ংক্রিয় VAD অক্ষম করা যেতে পারে true এই কনফিগারেশনে ক্লায়েন্ট ব্যবহারকারীর বক্তৃতা শনাক্ত করার জন্য এবং যথাযথ সময়ে activityStart এবং activityEnd বার্তা পাঠানোর জন্য দায়ী। এই কনফিগারেশনে একটি audioStreamEnd পাঠানো হয় না। পরিবর্তে, স্ট্রীমের কোনো বাধা একটি activityEnd বার্তা দ্বারা চিহ্নিত করা হয়।

পাইথন

config = {
    "response_modalities": ["TEXT"],
    "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())
    # ...

জাভাস্ক্রিপ্ট

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

session.sendRealtimeInput({ activityStart: {} })

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

);

session.sendRealtimeInput({ activityEnd: {} })

টোকেন গণনা

প্রত্যাবর্তিত সার্ভার বার্তার মেটাডেটা ক্ষেত্রে আপনি মোট ভোক্ত টোকেনের সংখ্যা খুঁজে পেতে পারেন।

পাইথন

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}")

জাভাস্ক্রিপ্ট

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 ক্ষেত্র সেট করে ইনপুট মিডিয়ার জন্য মিডিয়া রেজোলিউশন নির্দিষ্ট করতে পারেন:

পাইথন

from google.genai import types

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

জাভাস্ক্রিপ্ট

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

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

সীমাবদ্ধতা

আপনি যখন আপনার প্রকল্পের পরিকল্পনা করেন তখন লাইভ API-এর নিম্নলিখিত সীমাবদ্ধতাগুলি বিবেচনা করুন৷

প্রতিক্রিয়া পদ্ধতি

আপনি সেশন কনফিগারেশনে প্রতি সেশনে শুধুমাত্র একটি রেসপন্স মোডালিটি ( TEXT বা AUDIO ) সেট করতে পারেন। একটি কনফিগার ত্রুটি বার্তা উভয় ফলাফল সেট. এর মানে হল যে আপনি মডেলটিকে টেক্সট বা অডিওর সাথে প্রতিক্রিয়া জানাতে কনফিগার করতে পারেন, কিন্তু একই সেশনে উভয়ই নয়।

ক্লায়েন্ট প্রমাণীকরণ

লাইভ API শুধুমাত্র ডিফল্টরূপে সার্ভার-টু-সার্ভার প্রমাণীকরণ প্রদান করে। আপনি যদি একটি ক্লায়েন্ট-টু-সার্ভার পদ্ধতি ব্যবহার করে আপনার লাইভ এপিআই অ্যাপ্লিকেশন বাস্তবায়ন করেন, তাহলে নিরাপত্তা ঝুঁকি কমাতে আপনাকে ক্ষণস্থায়ী টোকেন ব্যবহার করতে হবে।

সেশনের সময়কাল

অডিও-শুধু সেশন 15 মিনিটের মধ্যে সীমাবদ্ধ, এবং অডিও প্লাস ভিডিও সেশন 2 মিনিটের মধ্যে সীমাবদ্ধ। যাইহোক, আপনি সেশনের মেয়াদে সীমাহীন এক্সটেনশনের জন্য বিভিন্ন সেশন পরিচালনার কৌশল কনফিগার করতে পারেন।

প্রসঙ্গ উইন্ডো

একটি সেশনের একটি প্রসঙ্গ উইন্ডো সীমা রয়েছে:

সমর্থিত ভাষা

লাইভ API নিম্নলিখিত ভাষা সমর্থন করে।

ভাষা BCP-47 কোড ভাষা BCP-47 কোড
জার্মান (জার্মানি) de-DE ইংরেজি (অস্ট্রেলিয়া)* en-AU
ইংরেজি (ইউকে)* en-GB ইংরেজি (ভারত) en-IN
ইংরেজি (মার্কিন) en-US স্প্যানিশ (মার্কিন) es-US
ফরাসি (ফ্রান্স) fr-FR হিন্দি (ভারত) hi-IN
পর্তুগিজ (ব্রাজিল) pt-BR আরবি (জেনারিক) ar-XA
স্প্যানিশ (স্পেন)* es-ES ফরাসি (কানাডা)* fr-CA
ইন্দোনেশিয়া (ইন্দোনেশিয়া) id-ID ইতালীয় (ইতালি) it-IT
জাপানিজ (জাপান) ja-JP তুর্কি (তুরস্ক) tr-TR
ভিয়েতনামী (ভিয়েতনাম) vi-VN বাংলা (ভারত) bn-IN
গুজরাটি (ভারত)* gu-IN কন্নড় (ভারত)* kn-IN
মারাঠি (ভারত) mr-IN মালায়লাম (ভারত)* ml-IN
তামিল (ভারত) ta-IN তেলেগু (ভারত) te-IN
ডাচ (নেদারল্যান্ডস) nl-NL কোরিয়ান (দক্ষিণ কোরিয়া) ko-KR
ম্যান্ডারিন চাইনিজ (চীন)* cmn-CN পোলিশ (পোল্যান্ড) pl-PL
রাশিয়ান (রাশিয়া) ru-RU থাই (থাইল্যান্ড) th-TH

একটি তারকাচিহ্ন (*) দিয়ে চিহ্নিত ভাষাগুলি নেটিভ অডিওর জন্য উপলব্ধ নয়

এরপর কি

,

এটি একটি ব্যাপক নির্দেশিকা যা লাইভ API-এর সাথে উপলব্ধ ক্ষমতা এবং কনফিগারেশনগুলিকে কভার করে৷ সাধারণ ব্যবহারের ক্ষেত্রে একটি ওভারভিউ এবং নমুনা কোডের জন্য লাইভ API পৃষ্ঠা দিয়ে শুরু করুন দেখুন।

আপনি শুরু করার আগে

  • মূল ধারণাগুলির সাথে নিজেকে পরিচিত করুন: আপনি যদি ইতিমধ্যে এটি না করে থাকেন তবে প্রথমে লাইভ API এর সাথে শুরু করুন পৃষ্ঠাটি পড়ুন৷ এটি আপনাকে লাইভ API-এর মৌলিক নীতিগুলির সাথে পরিচয় করিয়ে দেবে, এটি কীভাবে কাজ করে এবং বিভিন্ন মডেল এবং তাদের সংশ্লিষ্ট অডিও প্রজন্মের পদ্ধতিগুলির মধ্যে পার্থক্য ( নেটিভ অডিও বা অর্ধ-ক্যাসকেড)।
  • এআই স্টুডিওতে লাইভ এপিআই ব্যবহার করে দেখুন: আপনি বিল্ডিং শুরু করার আগে গুগল এআই স্টুডিওতে লাইভ এপিআই ব্যবহার করে দেখতে পারেন। Google AI স্টুডিওতে লাইভ API ব্যবহার করতে, স্ট্রিম নির্বাচন করুন।

একটি সংযোগ স্থাপন

নিম্নলিখিত উদাহরণ দেখায় কিভাবে একটি API কী দিয়ে একটি সংযোগ তৈরি করতে হয়:

পাইথন

import asyncio
from google import genai

client = genai.Client()

model = "gemini-live-2.5-flash-preview"
config = {"response_modalities": ["TEXT"]}

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

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

জাভাস্ক্রিপ্ট

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

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

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,
  });

  // Send content...

  session.close();
}

main();

মিথস্ক্রিয়া পদ্ধতি

নিম্নলিখিত বিভাগগুলি লাইভ এপিআই-তে উপলব্ধ বিভিন্ন ইনপুট এবং আউটপুট পদ্ধতিগুলির জন্য উদাহরণ এবং সমর্থনকারী প্রসঙ্গ প্রদান করে।

টেক্সট পাঠানো এবং গ্রহণ

আপনি কীভাবে পাঠ্য পাঠাতে এবং গ্রহণ করতে পারেন তা এখানে:

পাইথন

import asyncio
from google import genai

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        message = "Hello, how are you?"
        await session.send_client_content(
            turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
        )

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

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

জাভাস্ক্রিপ্ট

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

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

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.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();

ইনক্রিমেন্টাল কন্টেন্ট আপডেট

টেক্সট ইনপুট পাঠাতে, সেশন প্রসঙ্গ স্থাপন বা সেশন প্রসঙ্গ পুনরুদ্ধার করতে ক্রমবর্ধমান আপডেট ব্যবহার করুন। সংক্ষিপ্ত প্রসঙ্গের জন্য আপনি ঘটনার সঠিক ক্রম উপস্থাপন করতে পালাক্রমে মিথস্ক্রিয়া পাঠাতে পারেন:

পাইথন

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)

জাভাস্ক্রিপ্ট

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 })

দীর্ঘ প্রসঙ্গগুলির জন্য পরবর্তী মিথস্ক্রিয়াগুলির জন্য প্রসঙ্গ উইন্ডোটি মুক্ত করতে একটি একক বার্তা সারাংশ প্রদান করার পরামর্শ দেওয়া হয়। সেশন প্রসঙ্গ লোড করার জন্য অন্য পদ্ধতির জন্য সেশন পুনঃসূচনা দেখুন।

পাঠানো এবং অডিও গ্রহণ

সবচেয়ে সাধারণ অডিও উদাহরণ, অডিও-টু-অডিও , শুরু করা নির্দেশিকাতে কভার করা হয়েছে।

এখানে একটি অডিও-টু-টেক্সট উদাহরণ রয়েছে যা একটি WAV ফাইল পড়ে, এটি সঠিক বিন্যাসে পাঠায় এবং পাঠ্য আউটপুট গ্রহণ করে:

পাইথন

# Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
# Install helpers for converting files: pip install librosa soundfile
import asyncio
import io
from pathlib import Path
from google import genai
from google.genai import types
import soundfile as sf
import librosa

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:

        buffer = io.BytesIO()
        y, sr = librosa.load("sample.wav", sr=16000)
        sf.write(buffer, y, sr, format='RAW', subtype='PCM_16')
        buffer.seek(0)
        audio_bytes = buffer.read()

        # If already in correct format, you can use this:
        # audio_bytes = Path("sample.pcm").read_bytes()

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

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

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

জাভাস্ক্রিপ্ট

// Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
// Install helpers for converting files: npm install wavefile
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-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

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.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);
    }
  }

  session.close();
}

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

main();

এবং এখানে একটি পাঠ্য থেকে অডিও উদাহরণ. আপনি AUDIO রেসপন্স মোডালিটি হিসেবে সেট করে অডিও পেতে পারেন। এই উদাহরণটি WAV ফাইল হিসাবে প্রাপ্ত ডেটা সংরক্ষণ করে:

পাইথন

import asyncio
import wave
from google import genai

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        wf = wave.open("audio.wav", "wb")
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(24000)

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

        async for response in session.receive():
            if response.data is not None:
                wf.writeframes(response.data)

            # Un-comment this code to print audio data info
            # if response.server_content.model_turn is not None:
            #      print(response.server_content.model_turn.parts[0].inline_data.mime_type)

        wf.close()

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

জাভাস্ক্রিপ্ট

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-live-2.5-flash-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,
  });

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

  const turns = await handleTurn();

  // Combine audio data strings and save as wave file
  const combinedAudio = turns.reduce((acc, turn) => {
    if (turn.data) {
      const buffer = Buffer.from(turn.data, 'base64');
      const intArray = new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Int16Array.BYTES_PER_ELEMENT);
      return acc.concat(Array.from(intArray));
    }
    return acc;
  }, []);

  const audioBuffer = new Int16Array(combinedAudio);

  const wf = new WaveFile();
  wf.fromScratch(1, 24000, '16', audioBuffer);
  fs.writeFileSync('output.wav', wf.toBuffer());

  session.close();
}

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

main();

অডিও ফরম্যাট

লাইভ API-এ অডিও ডেটা সবসময় কাঁচা, সামান্য-এন্ডিয়ান, 16-বিট পিসিএম। অডিও আউটপুট সর্বদা 24kHz নমুনা হার ব্যবহার করে। ইনপুট অডিও নেটিভভাবে 16kHz, কিন্তু প্রয়োজন হলে লাইভ API পুনরায় নমুনা তৈরি করবে যাতে যেকোন নমুনা হার পাঠানো যায়। ইনপুট অডিওর নমুনা হার জানাতে, প্রতিটি অডিও-ধারণকারী ব্লবের MIME প্রকারকে audio/pcm;rate=16000 এর মতো একটি মান সেট করুন।

অডিও ট্রান্সক্রিপশন

আপনি সেটআপ কনফিগারেশনে output_audio_transcription পাঠিয়ে মডেলের অডিও আউটপুটের ট্রান্সক্রিপশন সক্ষম করতে পারেন। প্রতিলিপি ভাষা মডেলের প্রতিক্রিয়া থেকে অনুমান করা হয়.

পাইথন

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

client = genai.Client()
model = "gemini-live-2.5-flash-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())

জাভাস্ক্রিপ্ট

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

const ai = new GoogleGenAI({});
const model = 'gemini-live-2.5-flash-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 পাঠিয়ে অডিও ইনপুটের ট্রান্সক্রিপশন সক্ষম করতে পারেন।

পাইথন

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

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

config = {
    "response_modalities": ["TEXT"],
    "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())

জাভাস্ক্রিপ্ট

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-live-2.5-flash-preview';

const config = {
  responseModalities: [Modality.TEXT],
  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.serverContent && turn.serverContent.outputTranscription) {
      console.log("Transcription")
      console.log(turn.serverContent.outputTranscription.text);
    }
  }
  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();

অডিও এবং ভিডিও স্ট্রিম করুন

ভয়েস এবং ভাষা পরিবর্তন করুন

লাইভ এপিআই মডেল প্রতিটি আলাদা আলাদা কণ্ঠস্বর সমর্থন করে। অর্ধ-ক্যাসকেড Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus এবং Zephyr সমর্থন করে। নেটিভ অডিও অনেক লম্বা তালিকা সমর্থন করে ( টিটিএস মডেল তালিকার অনুরূপ)। আপনি এআই স্টুডিওতে সমস্ত ভয়েস শুনতে পারেন।

একটি ভয়েস নির্দিষ্ট করতে, সেশন কনফিগারেশনের অংশ হিসাবে speechConfig অবজেক্টের মধ্যে ভয়েস নাম সেট করুন:

পাইথন

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

জাভাস্ক্রিপ্ট

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

লাইভ API একাধিক ভাষা সমর্থন করে।

ভাষা পরিবর্তন করতে, সেশন কনফিগারেশনের অংশ হিসাবে speechConfig অবজেক্টের মধ্যে ভাষা কোড সেট করুন:

পাইথন

config = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "language_code": "de-DE"
    }
}

জাভাস্ক্রিপ্ট

const config = {
  responseModalities: [Modality.AUDIO],
  speechConfig: { languageCode: "de-DE" }
};

নেটিভ অডিও ক্ষমতা

নিম্নলিখিত ক্ষমতা শুধুমাত্র নেটিভ অডিও সঙ্গে উপলব্ধ. আপনি একটি মডেল এবং অডিও প্রজন্ম চয়ন করুন- এ নেটিভ অডিও সম্পর্কে আরও শিখতে পারেন৷

কিভাবে নেটিভ অডিও আউটপুট ব্যবহার করবেন

নেটিভ অডিও আউটপুট ব্যবহার করতে, একটি নেটিভ অডিও মডেল কনফিগার করুন এবং AUDIO তে response_modalities সেট করুন।

একটি সম্পূর্ণ উদাহরণের জন্য অডিও পাঠান এবং গ্রহণ দেখুন।

পাইথন

model = "gemini-2.5-flash-preview-native-audio-dialog"
config = types.LiveConnectConfig(response_modalities=["AUDIO"])

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

জাভাস্ক্রিপ্ট

const model = 'gemini-2.5-flash-preview-native-audio-dialog';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

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

  // Send audio input and receive audio

  session.close();
}

main();

কার্যকরী সংলাপ

এই বৈশিষ্ট্যটি জেমিনিকে তার প্রতিক্রিয়া শৈলীকে ইনপুট অভিব্যক্তি এবং টোনের সাথে মানিয়ে নিতে দেয়৷

ইফেক্টিভ ডায়ালগ ব্যবহার করতে, এপিআই সংস্করণটিকে v1alpha এ সেট করুন এবং সেটআপ বার্তায় enable_affective_dialog কে true সেট করুন:

পাইথন

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

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

জাভাস্ক্রিপ্ট

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

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

মনে রাখবেন যে ইফেক্টিভ ডায়ালগ বর্তমানে শুধুমাত্র নেটিভ অডিও আউটপুট মডেল দ্বারা সমর্থিত।

সক্রিয় অডিও

যখন এই বৈশিষ্ট্যটি সক্ষম করা থাকে, তখন বিষয়বস্তু প্রাসঙ্গিক না হলে জেমিনি সক্রিয়ভাবে প্রতিক্রিয়া না দেওয়ার সিদ্ধান্ত নিতে পারে।

এটি ব্যবহার করতে, এপিআই সংস্করণটিকে v1alpha এ সেট করুন এবং সেটআপ বার্তায় proactivity ক্ষেত্রটি কনফিগার করুন এবং proactive_audio কে true সেট করুন:

পাইথন

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

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

জাভাস্ক্রিপ্ট

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

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

নোট করুন যে সক্রিয় অডিও বর্তমানে শুধুমাত্র নেটিভ অডিও আউটপুট মডেল দ্বারা সমর্থিত।

চিন্তা সঙ্গে নেটিভ অডিও আউটপুট

নেটিভ অডিও আউটপুট চিন্তা করার ক্ষমতাকে সমর্থন করে, একটি পৃথক মডেল gemini-2.5-flash-exp-native-audio-thinking-dialog মাধ্যমে উপলব্ধ।

একটি সম্পূর্ণ উদাহরণের জন্য অডিও পাঠান এবং গ্রহণ দেখুন।

পাইথন

model = "gemini-2.5-flash-exp-native-audio-thinking-dialog"
config = types.LiveConnectConfig(response_modalities=["AUDIO"])

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

জাভাস্ক্রিপ্ট

const model = 'gemini-2.5-flash-exp-native-audio-thinking-dialog';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

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

  // Send audio input and receive audio

  session.close();
}

main();

ভয়েস অ্যাক্টিভিটি ডিটেকশন (VAD)

ভয়েস অ্যাক্টিভিটি ডিটেকশন (VAD) একজন ব্যক্তি যখন কথা বলছে তখন মডেলটিকে চিনতে দেয়। প্রাকৃতিক কথোপকথন তৈরি করার জন্য এটি অপরিহার্য, কারণ এটি ব্যবহারকারীকে যে কোনো সময় মডেলটিকে বাধা দিতে দেয়।

যখন VAD একটি বাধা শনাক্ত করে, তখন চলমান প্রজন্ম বাতিল এবং বাতিল করা হয়। শুধুমাত্র ক্লায়েন্টকে ইতিমধ্যে পাঠানো তথ্য সেশন ইতিহাসে রাখা হয়। সার্ভার তখন BidiGenerateContentServerContent কনটেন্ট বার্তা পাঠায় বিঘ্নের রিপোর্ট করতে।

জেমিনি সার্ভার তখন যেকোন মুলতুবি থাকা ফাংশন কল বাতিল করে এবং বাতিল করা কলগুলির আইডি সহ একটি BidiGenerateContentServerContent বার্তা পাঠায়।

পাইথন

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.

জাভাস্ক্রিপ্ট

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 ক্ষেত্রের সাথে কনফিগার করা যেতে পারে।

যখন অডিও স্ট্রীমটি এক সেকেন্ডের বেশি সময়ের জন্য বিরাম দেওয়া হয় (উদাহরণস্বরূপ, কারণ ব্যবহারকারী মাইক্রোফোনটি বন্ধ করে দিয়েছে), তখন কোনও ক্যাশে করা অডিও ফ্লাশ করার জন্য একটি audioStreamEnd ইভেন্ট পাঠানো উচিত। ক্লায়েন্ট যেকোনো সময় অডিও ডেটা পাঠানো আবার শুরু করতে পারে।

পাইথন

# 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-live-2.5-flash-preview"

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

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())

জাভাস্ক্রিপ্ট

// 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-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

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 রেফারেন্স দেখুন।

পাইথন

from google.genai import types

config = {
    "response_modalities": ["TEXT"],
    "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,
        }
    }
}

জাভাস্ক্রিপ্ট

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

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

স্বয়ংক্রিয় VAD অক্ষম করুন

বিকল্পভাবে, সেটআপ মেসেজে realtimeInputConfig.automaticActivityDetection.disabled সেট করে স্বয়ংক্রিয় VAD অক্ষম করা যেতে পারে true এই কনফিগারেশনে ক্লায়েন্ট ব্যবহারকারীর বক্তৃতা শনাক্ত করার জন্য এবং যথাযথ সময়ে activityStart এবং activityEnd বার্তা পাঠানোর জন্য দায়ী। এই কনফিগারেশনে একটি audioStreamEnd পাঠানো হয় না। পরিবর্তে, স্ট্রীমের কোনো বাধা একটি activityEnd বার্তা দ্বারা চিহ্নিত করা হয়।

পাইথন

config = {
    "response_modalities": ["TEXT"],
    "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())
    # ...

জাভাস্ক্রিপ্ট

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

session.sendRealtimeInput({ activityStart: {} })

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

);

session.sendRealtimeInput({ activityEnd: {} })

টোকেন গণনা

প্রত্যাবর্তিত সার্ভার বার্তার মেটাডেটা ক্ষেত্রে আপনি মোট ভোক্ত টোকেনের সংখ্যা খুঁজে পেতে পারেন।

পাইথন

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}")

জাভাস্ক্রিপ্ট

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 ক্ষেত্র সেট করে ইনপুট মিডিয়ার জন্য মিডিয়া রেজোলিউশন নির্দিষ্ট করতে পারেন:

পাইথন

from google.genai import types

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

জাভাস্ক্রিপ্ট

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

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

সীমাবদ্ধতা

আপনি যখন আপনার প্রকল্পের পরিকল্পনা করেন তখন লাইভ API-এর নিম্নলিখিত সীমাবদ্ধতাগুলি বিবেচনা করুন৷

প্রতিক্রিয়া পদ্ধতি

আপনি সেশন কনফিগারেশনে প্রতি সেশনে শুধুমাত্র একটি রেসপন্স মোডালিটি ( TEXT বা AUDIO ) সেট করতে পারেন। একটি কনফিগার ত্রুটি বার্তা উভয় ফলাফল সেট. এর মানে হল যে আপনি টেক্সট বা অডিওর সাথে সাড়া দেওয়ার জন্য মডেলটি কনফিগার করতে পারেন, কিন্তু একই সেশনে উভয়ই নয়।

ক্লায়েন্ট প্রমাণীকরণ

লাইভ API শুধুমাত্র ডিফল্টরূপে সার্ভার-টু-সার্ভার প্রমাণীকরণ প্রদান করে। আপনি যদি একটি ক্লায়েন্ট-টু-সার্ভার পদ্ধতি ব্যবহার করে আপনার লাইভ এপিআই অ্যাপ্লিকেশন বাস্তবায়ন করেন, তাহলে নিরাপত্তা ঝুঁকি কমাতে আপনাকে ক্ষণস্থায়ী টোকেন ব্যবহার করতে হবে।

সেশনের সময়কাল

অডিও-শুধু সেশন 15 মিনিটের মধ্যে সীমাবদ্ধ, এবং অডিও প্লাস ভিডিও সেশন 2 মিনিটের মধ্যে সীমাবদ্ধ। যাইহোক, আপনি সেশনের মেয়াদে সীমাহীন এক্সটেনশনের জন্য বিভিন্ন সেশন পরিচালনার কৌশল কনফিগার করতে পারেন।

প্রসঙ্গ উইন্ডো

একটি সেশনের একটি প্রসঙ্গ উইন্ডো সীমা রয়েছে:

সমর্থিত ভাষা

লাইভ API নিম্নলিখিত ভাষা সমর্থন করে।

ভাষা BCP-47 কোড ভাষা BCP-47 কোড
জার্মান (জার্মানি) de-DE ইংরেজি (অস্ট্রেলিয়া)* en-AU
ইংরেজি (ইউকে)* en-GB ইংরেজি (ভারত) en-IN
ইংরেজি (মার্কিন) en-US স্প্যানিশ (মার্কিন) es-US
ফরাসি (ফ্রান্স) fr-FR হিন্দি (ভারত) hi-IN
পর্তুগিজ (ব্রাজিল) pt-BR আরবি (জেনারিক) ar-XA
স্প্যানিশ (স্পেন)* es-ES ফরাসি (কানাডা)* fr-CA
ইন্দোনেশিয়া (ইন্দোনেশিয়া) id-ID ইতালীয় (ইতালি) it-IT
জাপানিজ (জাপান) ja-JP তুর্কি (তুরস্ক) tr-TR
ভিয়েতনামী (ভিয়েতনাম) vi-VN বাংলা (ভারত) bn-IN
গুজরাটি (ভারত)* gu-IN কন্নড় (ভারত)* kn-IN
মারাঠি (ভারত) mr-IN মালায়লাম (ভারত)* ml-IN
তামিল (ভারত) ta-IN তেলেগু (ভারত) te-IN
ডাচ (নেদারল্যান্ডস) nl-NL কোরিয়ান (দক্ষিণ কোরিয়া) ko-KR
ম্যান্ডারিন চাইনিজ (চীন)* cmn-CN পোলিশ (পোল্যান্ড) pl-PL
রাশিয়ান (রাশিয়া) ru-RU থাই (থাইল্যান্ড) th-TH

একটি তারকাচিহ্ন (*) দিয়ে চিহ্নিত ভাষাগুলি নেটিভ অডিওর জন্য উপলব্ধ নয়

এরপর কি

,

এটি একটি ব্যাপক নির্দেশিকা যা লাইভ API-এর সাথে উপলব্ধ ক্ষমতা এবং কনফিগারেশনগুলিকে কভার করে৷ সাধারণ ব্যবহারের ক্ষেত্রে একটি ওভারভিউ এবং নমুনা কোডের জন্য লাইভ API পৃষ্ঠা দিয়ে শুরু করুন দেখুন।

আপনি শুরু করার আগে

  • মূল ধারণাগুলির সাথে নিজেকে পরিচিত করুন: আপনি যদি ইতিমধ্যে এটি না করে থাকেন তবে প্রথমে লাইভ API এর সাথে শুরু করুন পৃষ্ঠাটি পড়ুন৷ এটি আপনাকে লাইভ API-এর মৌলিক নীতিগুলির সাথে পরিচয় করিয়ে দেবে, এটি কীভাবে কাজ করে এবং বিভিন্ন মডেল এবং তাদের সংশ্লিষ্ট অডিও প্রজন্মের পদ্ধতিগুলির মধ্যে পার্থক্য ( নেটিভ অডিও বা অর্ধ-ক্যাসকেড)।
  • এআই স্টুডিওতে লাইভ এপিআই ব্যবহার করে দেখুন: আপনি বিল্ডিং শুরু করার আগে গুগল এআই স্টুডিওতে লাইভ এপিআই ব্যবহার করে দেখতে পারেন। Google AI স্টুডিওতে লাইভ API ব্যবহার করতে, স্ট্রিম নির্বাচন করুন।

একটি সংযোগ স্থাপন

নিম্নলিখিত উদাহরণ দেখায় কিভাবে একটি API কী দিয়ে একটি সংযোগ তৈরি করতে হয়:

পাইথন

import asyncio
from google import genai

client = genai.Client()

model = "gemini-live-2.5-flash-preview"
config = {"response_modalities": ["TEXT"]}

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

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

জাভাস্ক্রিপ্ট

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

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

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,
  });

  // Send content...

  session.close();
}

main();

মিথস্ক্রিয়া পদ্ধতি

নিম্নলিখিত বিভাগগুলি লাইভ এপিআই-তে উপলব্ধ বিভিন্ন ইনপুট এবং আউটপুট পদ্ধতিগুলির জন্য উদাহরণ এবং সমর্থনকারী প্রসঙ্গ প্রদান করে।

টেক্সট পাঠানো এবং গ্রহণ

আপনি কীভাবে পাঠ্য পাঠাতে এবং গ্রহণ করতে পারেন তা এখানে:

পাইথন

import asyncio
from google import genai

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        message = "Hello, how are you?"
        await session.send_client_content(
            turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
        )

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

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

জাভাস্ক্রিপ্ট

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

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

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.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();

ইনক্রিমেন্টাল কন্টেন্ট আপডেট

টেক্সট ইনপুট পাঠাতে, সেশন প্রসঙ্গ স্থাপন বা সেশন প্রসঙ্গ পুনরুদ্ধার করতে ক্রমবর্ধমান আপডেট ব্যবহার করুন। সংক্ষিপ্ত প্রসঙ্গের জন্য আপনি ঘটনার সঠিক ক্রম উপস্থাপন করতে পালাক্রমে মিথস্ক্রিয়া পাঠাতে পারেন:

পাইথন

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)

জাভাস্ক্রিপ্ট

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 })

দীর্ঘ প্রসঙ্গগুলির জন্য পরবর্তী মিথস্ক্রিয়াগুলির জন্য প্রসঙ্গ উইন্ডোটি মুক্ত করতে একটি একক বার্তা সারাংশ প্রদান করার পরামর্শ দেওয়া হয়। সেশন প্রসঙ্গ লোড করার জন্য অন্য পদ্ধতির জন্য সেশন পুনঃসূচনা দেখুন।

পাঠানো এবং অডিও গ্রহণ

সবচেয়ে সাধারণ অডিও উদাহরণ, অডিও-টু-অডিও , শুরু করা নির্দেশিকাতে কভার করা হয়েছে।

এখানে একটি অডিও-টু-টেক্সট উদাহরণ রয়েছে যা একটি WAV ফাইল পড়ে, এটি সঠিক বিন্যাসে পাঠায় এবং পাঠ্য আউটপুট গ্রহণ করে:

পাইথন

# Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
# Install helpers for converting files: pip install librosa soundfile
import asyncio
import io
from pathlib import Path
from google import genai
from google.genai import types
import soundfile as sf
import librosa

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:

        buffer = io.BytesIO()
        y, sr = librosa.load("sample.wav", sr=16000)
        sf.write(buffer, y, sr, format='RAW', subtype='PCM_16')
        buffer.seek(0)
        audio_bytes = buffer.read()

        # If already in correct format, you can use this:
        # audio_bytes = Path("sample.pcm").read_bytes()

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

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

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

জাভাস্ক্রিপ্ট

// Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
// Install helpers for converting files: npm install wavefile
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-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

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.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);
    }
  }

  session.close();
}

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

main();

এবং এখানে একটি পাঠ্য থেকে অডিও উদাহরণ. আপনি AUDIO রেসপন্স মোডালিটি হিসেবে সেট করে অডিও পেতে পারেন। এই উদাহরণটি WAV ফাইল হিসাবে প্রাপ্ত ডেটা সংরক্ষণ করে:

পাইথন

import asyncio
import wave
from google import genai

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

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

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        wf = wave.open("audio.wav", "wb")
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(24000)

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

        async for response in session.receive():
            if response.data is not None:
                wf.writeframes(response.data)

            # Un-comment this code to print audio data info
            # if response.server_content.model_turn is not None:
            #      print(response.server_content.model_turn.parts[0].inline_data.mime_type)

        wf.close()

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

জাভাস্ক্রিপ্ট

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-live-2.5-flash-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,
  });

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

  const turns = await handleTurn();

  // Combine audio data strings and save as wave file
  const combinedAudio = turns.reduce((acc, turn) => {
    if (turn.data) {
      const buffer = Buffer.from(turn.data, 'base64');
      const intArray = new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Int16Array.BYTES_PER_ELEMENT);
      return acc.concat(Array.from(intArray));
    }
    return acc;
  }, []);

  const audioBuffer = new Int16Array(combinedAudio);

  const wf = new WaveFile();
  wf.fromScratch(1, 24000, '16', audioBuffer);
  fs.writeFileSync('output.wav', wf.toBuffer());

  session.close();
}

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

main();

অডিও ফরম্যাট

লাইভ API-এ অডিও ডেটা সবসময় কাঁচা, সামান্য-এন্ডিয়ান, 16-বিট পিসিএম। অডিও আউটপুট সর্বদা 24kHz নমুনা হার ব্যবহার করে। ইনপুট অডিও নেটিভভাবে 16kHz, কিন্তু প্রয়োজন হলে লাইভ API পুনরায় নমুনা তৈরি করবে যাতে যেকোন নমুনা হার পাঠানো যায়। ইনপুট অডিওর নমুনা হার জানাতে, প্রতিটি অডিও-ধারণকারী ব্লবের MIME প্রকারকে audio/pcm;rate=16000 এর মতো একটি মান সেট করুন।

অডিও ট্রান্সক্রিপশন

আপনি সেটআপ কনফিগারেশনে output_audio_transcription পাঠিয়ে মডেলের অডিও আউটপুটের ট্রান্সক্রিপশন সক্ষম করতে পারেন। প্রতিলিপি ভাষা মডেলের প্রতিক্রিয়া থেকে অনুমান করা হয়.

পাইথন

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

client = genai.Client()
model = "gemini-live-2.5-flash-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())

জাভাস্ক্রিপ্ট

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

const ai = new GoogleGenAI({});
const model = 'gemini-live-2.5-flash-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 পাঠিয়ে অডিও ইনপুটের ট্রান্সক্রিপশন সক্ষম করতে পারেন।

পাইথন

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

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

config = {
    "response_modalities": ["TEXT"],
    "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())

জাভাস্ক্রিপ্ট

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-live-2.5-flash-preview';

const config = {
  responseModalities: [Modality.TEXT],
  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.serverContent && turn.serverContent.outputTranscription) {
      console.log("Transcription")
      console.log(turn.serverContent.outputTranscription.text);
    }
  }
  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();

অডিও এবং ভিডিও স্ট্রিম করুন

ভয়েস এবং ভাষা পরিবর্তন করুন

লাইভ এপিআই মডেল প্রতিটি আলাদা আলাদা কণ্ঠস্বর সমর্থন করে। অর্ধ-ক্যাসকেড Puck, Charon, Kore, Fenrir, Aoede, Leda, Orus এবং Zephyr সমর্থন করে। নেটিভ অডিও অনেক লম্বা তালিকা সমর্থন করে ( টিটিএস মডেল তালিকার অনুরূপ)। আপনি এআই স্টুডিওতে সমস্ত ভয়েস শুনতে পারেন।

একটি ভয়েস নির্দিষ্ট করতে, সেশন কনফিগারেশনের অংশ হিসাবে speechConfig অবজেক্টের মধ্যে ভয়েস নাম সেট করুন:

পাইথন

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

জাভাস্ক্রিপ্ট

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

লাইভ API একাধিক ভাষা সমর্থন করে।

ভাষা পরিবর্তন করতে, সেশন কনফিগারেশনের অংশ হিসাবে speechConfig অবজেক্টের মধ্যে ভাষা কোড সেট করুন:

পাইথন

config = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "language_code": "de-DE"
    }
}

জাভাস্ক্রিপ্ট

const config = {
  responseModalities: [Modality.AUDIO],
  speechConfig: { languageCode: "de-DE" }
};

নেটিভ অডিও ক্ষমতা

নিম্নলিখিত ক্ষমতা শুধুমাত্র নেটিভ অডিও সঙ্গে উপলব্ধ. আপনি একটি মডেল এবং অডিও প্রজন্ম চয়ন করুন- এ নেটিভ অডিও সম্পর্কে আরও শিখতে পারেন৷

কিভাবে নেটিভ অডিও আউটপুট ব্যবহার করবেন

নেটিভ অডিও আউটপুট ব্যবহার করতে, একটি নেটিভ অডিও মডেল কনফিগার করুন এবং AUDIO তে response_modalities সেট করুন।

একটি সম্পূর্ণ উদাহরণের জন্য অডিও পাঠান এবং গ্রহণ দেখুন।

পাইথন

model = "gemini-2.5-flash-preview-native-audio-dialog"
config = types.LiveConnectConfig(response_modalities=["AUDIO"])

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

জাভাস্ক্রিপ্ট

const model = 'gemini-2.5-flash-preview-native-audio-dialog';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

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

  // Send audio input and receive audio

  session.close();
}

main();

কার্যকরী সংলাপ

এই বৈশিষ্ট্যটি জেমিনিকে তার প্রতিক্রিয়া শৈলীকে ইনপুট অভিব্যক্তি এবং টোনের সাথে মানিয়ে নিতে দেয়৷

ইফেক্টিভ ডায়ালগ ব্যবহার করতে, এপিআই সংস্করণটিকে v1alpha এ সেট করুন এবং সেটআপ বার্তায় enable_affective_dialog কে true সেট করুন:

পাইথন

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

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

জাভাস্ক্রিপ্ট

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

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

মনে রাখবেন যে ইফেক্টিভ ডায়ালগ বর্তমানে শুধুমাত্র নেটিভ অডিও আউটপুট মডেল দ্বারা সমর্থিত।

সক্রিয় অডিও

যখন এই বৈশিষ্ট্যটি সক্ষম করা থাকে, তখন বিষয়বস্তু প্রাসঙ্গিক না হলে জেমিনি সক্রিয়ভাবে প্রতিক্রিয়া না দেওয়ার সিদ্ধান্ত নিতে পারে।

এটি ব্যবহার করতে, এপিআই সংস্করণটিকে v1alpha এ সেট করুন এবং সেটআপ বার্তায় proactivity ক্ষেত্রটি কনফিগার করুন এবং proactive_audio কে true সেট করুন:

পাইথন

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

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

জাভাস্ক্রিপ্ট

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

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

নোট করুন যে সক্রিয় অডিও বর্তমানে শুধুমাত্র নেটিভ অডিও আউটপুট মডেল দ্বারা সমর্থিত।

চিন্তা সঙ্গে নেটিভ অডিও আউটপুট

নেটিভ অডিও আউটপুট চিন্তা করার ক্ষমতাকে সমর্থন করে, একটি পৃথক মডেল gemini-2.5-flash-exp-native-audio-thinking-dialog মাধ্যমে উপলব্ধ।

একটি সম্পূর্ণ উদাহরণের জন্য অডিও পাঠান এবং গ্রহণ দেখুন।

পাইথন

model = "gemini-2.5-flash-exp-native-audio-thinking-dialog"
config = types.LiveConnectConfig(response_modalities=["AUDIO"])

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

জাভাস্ক্রিপ্ট

const model = 'gemini-2.5-flash-exp-native-audio-thinking-dialog';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

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

  // Send audio input and receive audio

  session.close();
}

main();

ভয়েস অ্যাক্টিভিটি ডিটেকশন (VAD)

ভয়েস অ্যাক্টিভিটি ডিটেকশন (VAD) একজন ব্যক্তি যখন কথা বলছে তখন মডেলটিকে চিনতে দেয়। প্রাকৃতিক কথোপকথন তৈরি করার জন্য এটি অপরিহার্য, কারণ এটি ব্যবহারকারীকে যে কোনো সময় মডেলটিকে বাধা দিতে দেয়।

যখন VAD একটি বাধা শনাক্ত করে, তখন চলমান প্রজন্ম বাতিল এবং বাতিল করা হয়। শুধুমাত্র ক্লায়েন্টকে ইতিমধ্যে পাঠানো তথ্য সেশন ইতিহাসে রাখা হয়। সার্ভার তখন BidiGenerateContentServerContent কনটেন্ট বার্তা পাঠায় বিঘ্নের রিপোর্ট করতে।

জেমিনি সার্ভার তখন যেকোন মুলতুবি থাকা ফাংশন কল বাতিল করে এবং বাতিল করা কলগুলির আইডি সহ একটি BidiGenerateContentServerContent বার্তা পাঠায়।

পাইথন

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.

জাভাস্ক্রিপ্ট

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 ক্ষেত্রের সাথে কনফিগার করা যেতে পারে।

যখন অডিও স্ট্রীমটি এক সেকেন্ডের বেশি সময়ের জন্য বিরাম দেওয়া হয় (উদাহরণস্বরূপ, কারণ ব্যবহারকারী মাইক্রোফোনটি বন্ধ করে দিয়েছে), তখন কোনও ক্যাশে করা অডিও ফ্লাশ করার জন্য একটি audioStreamEnd ইভেন্ট পাঠানো উচিত। ক্লায়েন্ট যেকোনো সময় অডিও ডেটা পাঠানো আবার শুরু করতে পারে।

পাইথন

# 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-live-2.5-flash-preview"

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

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())

জাভাস্ক্রিপ্ট

// 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-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

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 রেফারেন্স দেখুন।

পাইথন

from google.genai import types

config = {
    "response_modalities": ["TEXT"],
    "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,
        }
    }
}

জাভাস্ক্রিপ্ট

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

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

স্বয়ংক্রিয় VAD অক্ষম করুন

বিকল্পভাবে, সেটআপ মেসেজে realtimeInputConfig.automaticActivityDetection.disabled সেট করে স্বয়ংক্রিয় VAD অক্ষম করা যেতে পারে true এই কনফিগারেশনে ক্লায়েন্ট ব্যবহারকারীর বক্তৃতা শনাক্ত করার জন্য এবং যথাযথ সময়ে activityStart এবং activityEnd বার্তা পাঠানোর জন্য দায়ী। এই কনফিগারেশনে একটি audioStreamEnd পাঠানো হয় না। পরিবর্তে, স্ট্রীমের কোনো বাধা একটি activityEnd বার্তা দ্বারা চিহ্নিত করা হয়।

পাইথন

config = {
    "response_modalities": ["TEXT"],
    "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())
    # ...

জাভাস্ক্রিপ্ট

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

session.sendRealtimeInput({ activityStart: {} })

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

);

session.sendRealtimeInput({ activityEnd: {} })

টোকেন গণনা

প্রত্যাবর্তিত সার্ভার বার্তার মেটাডেটা ক্ষেত্রে আপনি মোট ভোক্ত টোকেনের সংখ্যা খুঁজে পেতে পারেন।

পাইথন

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}")

জাভাস্ক্রিপ্ট

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 ক্ষেত্র সেট করে ইনপুট মিডিয়ার জন্য মিডিয়া রেজোলিউশন নির্দিষ্ট করতে পারেন:

পাইথন

from google.genai import types

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

জাভাস্ক্রিপ্ট

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

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

সীমাবদ্ধতা

আপনি যখন আপনার প্রকল্পের পরিকল্পনা করেন তখন লাইভ API-এর নিম্নলিখিত সীমাবদ্ধতাগুলি বিবেচনা করুন৷

প্রতিক্রিয়া পদ্ধতি

আপনি সেশন কনফিগারেশনে প্রতি সেশনে শুধুমাত্র একটি রেসপন্স মোডালিটি ( TEXT বা AUDIO ) সেট করতে পারেন। একটি কনফিগার ত্রুটি বার্তা উভয় ফলাফল সেট. এর মানে হল যে আপনি মডেলটিকে টেক্সট বা অডিওর সাথে প্রতিক্রিয়া জানাতে কনফিগার করতে পারেন, কিন্তু একই সেশনে উভয়ই নয়।

ক্লায়েন্ট প্রমাণীকরণ

লাইভ API শুধুমাত্র ডিফল্টরূপে সার্ভার-টু-সার্ভার প্রমাণীকরণ প্রদান করে। আপনি যদি একটি ক্লায়েন্ট-টু-সার্ভার পদ্ধতি ব্যবহার করে আপনার লাইভ এপিআই অ্যাপ্লিকেশন বাস্তবায়ন করেন, তাহলে নিরাপত্তা ঝুঁকি কমাতে আপনাকে ক্ষণস্থায়ী টোকেন ব্যবহার করতে হবে।

সেশনের সময়কাল

অডিও-শুধু সেশন 15 মিনিটের মধ্যে সীমাবদ্ধ, এবং অডিও প্লাস ভিডিও সেশন 2 মিনিটের মধ্যে সীমাবদ্ধ। যাইহোক, আপনি সেশনের মেয়াদে সীমাহীন এক্সটেনশনের জন্য বিভিন্ন সেশন পরিচালনার কৌশল কনফিগার করতে পারেন।

প্রসঙ্গ উইন্ডো

একটি সেশনের একটি প্রসঙ্গ উইন্ডো সীমা রয়েছে:

সমর্থিত ভাষা

লাইভ API নিম্নলিখিত ভাষা সমর্থন করে।

ভাষা BCP-47 কোড ভাষা BCP-47 কোড
জার্মান (জার্মানি) de-DE ইংরেজি (অস্ট্রেলিয়া)* en-AU
ইংরেজি (ইউকে)* en-GB ইংরেজি (ভারত) en-IN
ইংরেজি (মার্কিন) en-US স্প্যানিশ (মার্কিন) es-US
ফরাসি (ফ্রান্স) fr-FR হিন্দি (ভারত) hi-IN
পর্তুগিজ (ব্রাজিল) pt-BR আরবি (জেনারিক) ar-XA
স্প্যানিশ (স্পেন)* es-ES ফরাসি (কানাডা)* fr-CA
ইন্দোনেশিয়া (ইন্দোনেশিয়া) id-ID ইতালীয় (ইতালি) it-IT
জাপানিজ (জাপান) ja-JP তুর্কি (তুরস্ক) tr-TR
ভিয়েতনামী (ভিয়েতনাম) vi-VN বাংলা (ভারত) bn-IN
গুজরাটি (ভারত)* gu-IN কন্নড় (ভারত)* kn-IN
মারাঠি (ভারত) mr-IN মালায়লাম (ভারত)* ml-IN
তামিল (ভারত) ta-IN তেলেগু (ভারত) te-IN
ডাচ (নেদারল্যান্ডস) nl-NL কোরিয়ান (দক্ষিণ কোরিয়া) ko-KR
ম্যান্ডারিন চাইনিজ (চীন)* cmn-CN পোলিশ (পোল্যান্ড) pl-PL
রাশিয়ান (রাশিয়া) ru-RU থাই (থাইল্যান্ড) th-TH

একটি তারকাচিহ্ন (*) দিয়ে চিহ্নিত ভাষাগুলি নেটিভ অডিওর জন্য উপলব্ধ নয়

এরপর কি