Skip to main content

Integrasikan model percakapan suara real-time

Minta tool Agent membuat dan menjalankan klien suara, lalu terhubung ke model percakapan suara real-time Token Plan.

Model yang didukung

ModelKemampuan
qwen-audio-3.0-realtime-plusPercakapan suara real-time
Untuk model lainnya, lihat model percakapan suara real-time yang didukung Token Plan.

Prasyarat

  • Langganan Token Plan. Untuk Edisi Personal, dapatkan API key sk-sp- dari My Subscription (Personal). Untuk Edisi Tim, tetapkan kursi di Manajemen anggota, lalu dapatkan API key.
  • Python 3.9 atau yang lebih baru, mikrofon, dan speaker.

Langkah 1: Kirim instruksi integrasi ke tool Agent

Perluas instruksi integrasi di bawah dan kirim ke tool Agent yang Anda gunakan. Tool tersebut membaca Token Plan key yang sudah dikonfigurasi, menginstal dependensi, membuat qwen_realtime_voice.py, dan menjalankannya. Tidak perlu mengonfigurasi key secara manual atau menulis Python.
Siapkan model percakapan suara real-time Token Plan qwen-audio-3.0-realtime-plus di proyek saat ini:

1. Gunakan API key Token Plan yang sudah dikonfigurasi di tool Agent saat ini (utamakan TOKEN_PLAN_API_KEY, lalu ANTHROPIC_AUTH_TOKEN). Jika keduanya tidak tersedia, minta saya mengonfigurasi Token Plan key di tool Agent terlebih dahulu. Jangan tampilkan key atau menuliskannya ke file atau log.
2. Instal dependensi: pip install "websockets>=15" sounddevice certifi
3. Buat qwen_realtime_voice.py dengan konten berikut:

```python
#!/usr/bin/env python3
import asyncio
import base64
import json
import os
import queue
import ssl
import threading

import certifi
import sounddevice as sd
import websockets

API_KEY = os.environ.get("TOKEN_PLAN_API_KEY") or os.environ.get("ANTHROPIC_AUTH_TOKEN")
if not API_KEY:
    raise SystemExit("Token Plan API Key not found. Configure it in the Agent tool first.")
WS_URL = "wss://token-plan.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime?model=qwen-audio-3.0-realtime-plus"

play_queue = queue.Queue()


def play_audio():
    with sd.RawOutputStream(samplerate=24000, channels=1, dtype="int16") as stream:
        while True:
            chunk = play_queue.get()
            if chunk is None:
                break
            stream.write(chunk)


async def receive(ws):
    transcript = []
    async for message in ws:
        event = json.loads(message)
        event_type = event["type"]
        if event_type == "conversation.item.input_audio_transcription.completed":
            print(f"\n[You] {event.get('transcript', '')}", flush=True)
        elif event_type == "response.audio.delta":
            play_queue.put(base64.b64decode(event["delta"]))
        elif event_type == "response.audio_transcript.delta":
            transcript.append(event.get("delta", ""))
        elif event_type == "response.audio_transcript.done":
            print(f"[AI] {''.join(transcript)}", flush=True)
            transcript.clear()
        elif event_type == "error":
            print(f"[Error] {event}", flush=True)


async def send_mic(ws):
    loop = asyncio.get_running_loop()
    audio_queue = asyncio.Queue()

    def callback(indata, frames, time_info, status):
        loop.call_soon_threadsafe(audio_queue.put_nowait, bytes(indata))

    with sd.RawInputStream(
        samplerate=16000,
        channels=1,
        dtype="int16",
        blocksize=1600,
        callback=callback,
    ):
        print("Start speaking. Press Ctrl+C to stop.", flush=True)
        while True:
            chunk = await audio_queue.get()
            await ws.send(
                json.dumps(
                    {
                        "type": "input_audio_buffer.append",
                        "audio": base64.b64encode(chunk).decode(),
                    }
                )
            )


async def main():
    context = ssl.create_default_context(cafile=certifi.where())
    async with websockets.connect(
        WS_URL,
        ssl=context,
        additional_headers={"Authorization": f"Bearer {API_KEY}"},
        max_size=None,
    ) as ws:
        await ws.recv()
        await ws.send(
            json.dumps(
                {
                    "type": "session.update",
                    "session": {
                        "modalities": ["audio", "text"],
                        "voice": "longanqian",
                        "instructions": "You are a voice assistant. Keep answers concise and natural.",
                        "input_audio_format": "pcm",
                        "output_audio_format": "pcm",
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 600,
                        },
                    },
                }
            )
        )
        threading.Thread(target=play_audio, daemon=True).start()
        await asyncio.gather(receive(ws), send_mic(ws))


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass
    finally:
        play_queue.put(None)
```

4. Gunakan tool Bash untuk menjalankan python3 qwen_realtime_voice.py dengan timeout 600000 milidetik.
5. Setelah skrip dimulai, minta pengguna mulai berbicara dan tekan Ctrl+C untuk berhenti.
Saat pertama kali dijalankan, izinkan aplikasi yang menjalankan tool Agent (seperti Cursor atau Terminal) mengakses mikrofon di pengaturan sistem. Jika tidak, skrip tidak menerima audio. Gunakan headphone agar audio dari speaker tidak ditangkap mikrofon dan menghentikan respons.

Langkah 2: Mulai percakapan suara

Setelah tool Agent menjalankan skrip, mulailah berbicara saat pesan mulai muncul. Terminal menampilkan transkrip dan balasan model, dan speaker memutar audio model. Tekan Ctrl+C untuk mengakhiri sesi.
Tool AI menginstal dependensi, membuat skrip, dan memulai sesi. Data audio dikirim antara klien lokal dan Token Plan dan tidak melewati model teks tool Agent.

Simpan sebagai ekstensi tool

Untuk menggunakan lagi, minta tool Agent menyimpan instruksi di atas sebagai Skill, Slash Command, atau konfigurasi Agent pada tool yang Anda gunakan, lalu jalankan melalui pemicu tool tersebut. Mekanisme ekstensi dan jalur untuk tool umum:
ToolMekanisme ekstensiJalur file konfigurasi
Claude CodeSlash Command.claude/commands/voice-chat.md
CodexSkill~/.codex/skills/token-plan-voice/SKILL.md
Qwen CodeSkill~/.qwen/skills/voice-chat/SKILL.md
OpenCodeAgent.opencode/agents/voice-chat.md
OpenClawSkill~/.openclaw/workspace/skills/token-plan-voice/SKILL.md
Hermes AgentSkill~/.hermes/skills/media/voice-chat/SKILL.md
QoderSkill~/.qoder/skills/voice-chat/SKILL.md

Batasan

  • Saat menggunakan speaker, audio model dapat ditangkap mikrofon dan menghentikan respons. Gunakan headphone.
  • Panggilan Bash dari tool Agent memiliki batas waktu. Untuk percakapan panjang, jalankan skrip sebagai proses mandiri atau bungkus dalam server MCP.
  • Solusi saat ini hanya menangani input dan output suara.