0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

Bun/TypeScriptでリアルタイム音声AIのバックプレッシャを設計する:WebSocket+非同期キュー

0
Posted at

本稿は、AceRound AI の自社ブログで扱った「リアルタイムAI面接アシスタント」のプロダクト文脈を、実装面だけに絞って再構成した技術メモです。元記事: https://aceround.app/ja/blog/real-time-ai-interview-helper

ここでは製品紹介ではなく、リアルタイム音声AIを作るときに、WebSocket入力・STT処理・LLM処理の間でどうバックプレッシャを扱うかを扱います。面接AIに限らず、会議要約、コールセンター支援、ライブ字幕でも同じ問題が出ます。

real-time audio AI pipeline

結論

リアルタイム音声AIで一番避けたいのは「正確だが遅い」パイプラインです。

音声は 20ms ごとに届き続けます。STT や LLM が一瞬でも詰まると、入力キューはすぐに古い音声で埋まります。古い音声を丁寧に処理しても、ユーザーにはすでに遅すぎます。

そのため、ライブ用途では次の設計にします。

  • WebSocket の message ハンドラでは重い処理をしない
  • 接続ごとに上限付きキューを持つ
  • STT worker は小さくバッチングして処理する
  • キューが溢れたら「古いフレームを捨てる」など、用途に応じた方針を明示する
  • queueDepth、lagMs、droppedFrames を常に観測する

この記事では、Bun + TypeScript の最小実装でこの構成を作ります。Node.js で ws を使う場合も、構造はほぼ同じです。

なぜ message ハンドラで STT を await しないのか

一番素直に書くと、こうなりがちです。

ws.onmessage = async (event) => {
  const transcript = await stt(event.data);
  const answer = await llm(transcript);
  ws.send(JSON.stringify(answer));
};

これはデモでは動きますが、本番のライブ音声には弱いです。

理由は単純です。音声フレームは止まらないのに、STT と LLM は外部サービスやモデル推論に依存します。1 回だけ 500ms 遅れても、その間に 20ms フレームが 25 個届きます。さらに次の STT も遅れると、遅延は回復せず積み上がります。

ライブ用途では「全フレームを必ず処理する」よりも、「現在の会話に近いフレームを低遅延で処理する」ほうが重要です。

設計方針

接続ごとに、次のような流れに分けます。

  1. WebSocket は binary frame を受け取る
  2. message ハンドラはフレームをキューに入れてすぐ返る
  3. worker loop がキューから小さな batch を取り出す
  4. STT の partial result を返す
  5. 必要なら LLM 側で質問検出・文脈構築に進める

ポイントは、入力と処理を切り離すことです。

上限付き非同期キュー

まず、古いフレームを捨てられる非同期キューを作ります。

/// <reference types="bun" />

type AudioFrame = {
  seq: number;
  receivedAt: number;
  payload: Uint8Array;
};

class BoundedAsyncQueue<T> {
  private items: T[] = [];
  private waiters: Array<(value: T | undefined) => void> = [];
  private closed = false;

  constructor(
    private readonly maxSize: number,
    private readonly onDrop?: (item: T) => void,
  ) {}

  get size() {
    return this.items.length;
  }

  push(item: T) {
    if (this.closed) return false;

    const waiter = this.waiters.shift();
    if (waiter) {
      waiter(item);
      return true;
    }

    if (this.items.length >= this.maxSize) {
      const dropped = this.items.shift(); // live用途では古い音声を優先的に捨てる
      if (dropped) this.onDrop?.(dropped);
    }

    this.items.push(item);
    return true;
  }

  shift() {
    if (this.items.length > 0) return Promise.resolve(this.items.shift());
    if (this.closed) return Promise.resolve(undefined);

    return new Promise<T | undefined>((resolve) => {
      this.waiters.push(resolve);
    });
  }

  close() {
    this.closed = true;
    for (const waiter of this.waiters.splice(0)) waiter(undefined);
  }
}

ここでの drop oldest は万能ではありません。

録音の完全性が必要な通話監査なら、フレームを捨てずに接続を閉じるほうが正しい場合があります。一方で、面接補助やライブ字幕のような「今の発話に追いつく」ことが重要な用途では、古いフレームを抱え続けるほうがユーザー体験を壊します。

小さくバッチングする

STT に 20ms フレームを 1 個ずつ投げると、ネットワーク往復や API 呼び出しのオーバーヘッドが大きくなります。逆に 2 秒分ためると、ライブ感がなくなります。

ここでは「最大 10 フレーム、または 80ms 待ったら処理」という簡単な batcher にします。

async function* batches(
  queue: BoundedAsyncQueue<AudioFrame>,
  maxBatchSize: number,
  maxWaitMs: number,
) {
  while (true) {
    const first = await queue.shift();
    if (!first) return;

    const batch = [first];
    const deadline = Date.now() + maxWaitMs;

    while (batch.length < maxBatchSize) {
      const timeout = Math.max(0, deadline - Date.now());
      if (timeout === 0) break;

      const next = await Promise.race([
        queue.shift(),
        new Promise<undefined>((resolve) => setTimeout(resolve, timeout)),
      ]);

      if (!next) break;
      batch.push(next);
    }

    yield batch;
  }
}

実運用では、ここで PCM を結合したり、Opus をデコードしたり、STT API が求める chunk 形式に変換します。この記事ではバックプレッシャの形を見るため、STT はダミー関数にします。

async function fakeStt(frames: AudioFrame[]) {
  await Bun.sleep(45); // 外部STTの遅延を模擬
  return `partial transcript: ${frames[0].seq}-${frames.at(-1)?.seq}`;
}

WebSocket サーバー

Bun の WebSocket サーバーで最小構成を書きます。

type SessionData = {
  queue: BoundedAsyncQueue<AudioFrame>;
  nextSeq: number;
  stats: {
    droppedFrames: number;
  };
};

async function consume(ws: ServerWebSocket<SessionData>) {
  for await (const batch of batches(ws.data.queue, 10, 80)) {
    const lagMs = Date.now() - batch[0].receivedAt;
    const text = await fakeStt(batch);

    ws.send(
      JSON.stringify({
        type: "partial",
        text,
        lagMs,
        queueDepth: ws.data.queue.size,
        droppedFrames: ws.data.stats.droppedFrames,
      }),
    );
  }
}

Bun.serve<SessionData>({
  port: 8787,

  fetch(req, server) {
    const stats = { droppedFrames: 0 };
    const data: SessionData = {
      nextSeq: 0,
      stats,
      queue: new BoundedAsyncQueue<AudioFrame>(150, () => {
        stats.droppedFrames += 1;
      }),
    };

    if (server.upgrade(req, { data })) return;
    return new Response("WebSocket endpoint", { status: 426 });
  },

  websocket: {
    open(ws) {
      void consume(ws);
    },

    message(ws, message) {
      if (typeof message === "string") return;

      ws.data.queue.push({
        seq: ws.data.nextSeq++,
        receivedAt: Date.now(),
        payload: new Uint8Array(message),
      });
    },

    close(ws) {
      ws.data.queue.close();
    },
  },
});

重要なのは、message の中で STT を呼ばないことです。message は受信、採番、enqueue だけにします。

動作確認用クライアント

ブラウザでも動きますが、ここでは Bun の WebSocket で 20ms ごとに 640 bytes のダミーフレームを送ります。

const ws = new WebSocket("ws://localhost:8787");

ws.addEventListener("open", () => {
  setInterval(() => {
    ws.send(new Uint8Array(640)); // 16kHz/16bit/mono の 20ms 相当のサイズ
  }, 20);
});

ws.addEventListener("message", (event) => {
  console.log(event.data);
});

ローカルで試すなら、サーバーを server.ts、クライアントを client.ts に分けて実行します。

bun run server.ts
bun run client.ts

手元の確認では、次のような partial result が返りました。

{
  "type": "partial",
  "text": "partial transcript: 0-3",
  "lagMs": 81,
  "queueDepth": 2,
  "droppedFrames": 0
}

この出力で見たいのは、文字起こしの内容ではなく lagMs と queueDepth です。負荷を上げたときにこの 2 つが増え続けるなら、STT worker の並列数、batch サイズ、drop 方針、あるいは上流の音声送信レートを見直す必要があります。

どのフレームを捨てるべきか

リアルタイム音声AIでは、overflow policy が設計判断になります。

1. 古いフレームを捨てる

ライブ字幕、面接補助、会議中のリアルタイムヒントでは、この方針が自然です。ユーザーが欲しいのは「数秒前の完全な解析」ではなく「今の発話に追いつくこと」だからです。

欠点は、音声の一部が抜けるため、STT の文脈が壊れる可能性があることです。実運用では VAD と組み合わせ、無音区間や短いフィラーを優先的に捨てるほうが安全です。

2. 新しいフレームを拒否する

録音や監査ログを重視する用途では、古いフレームを捨てると後から説明できません。この場合は、新しいフレームを拒否する、または接続を閉じてクライアントに再接続させるほうが明快です。

3. 入力側に送信レートを落とさせる

クライアントを制御できるなら、サーバーから slow_down のような制御メッセージを返す方法もあります。ただしブラウザのマイク入力や OS の音声キャプチャは完全には止められないため、サーバー側の上限付きキューは結局必要です。

LLM に渡す前に見るべき指標

STT の partial result をそのまま LLM に投げると、LLM 側のコストと遅延が跳ねます。実際には、次のようなゲートを置きます。

  • lagMs が大きすぎる partial は捨てる
  • 文末らしい pause があるときだけ LLM に渡す
  • 質問らしいパターンだけを抽出する
  • 同じ質問候補を debounce する
  • LLM には全文ではなく、直近 N 秒と必要なメタ情報だけ渡す

面接や会議のような会話では、LLM に渡すべきイベントは「すべての単語」ではありません。質問、依頼、決定事項、トピック変更など、意味のある境界だけを拾うほうが安定します。

面接で説明するなら

この設計は、システム設計面接でも説明しやすい題材です。

聞かれやすい論点は次の通りです。

  • WebSocket 層は I/O と enqueue だけにして、推論処理から分離する
  • 接続ごとのキューは必ず bounded にする
  • ライブ用途では tail latency を重視し、古い work を捨てる選択肢を持つ
  • STT は小さく batch し、LLM はさらにイベントで間引く
  • queueDepth、lagMs、droppedFrames をメトリクス化する

「キューを入れました」で終わらせず、キューが溢れたときにどうするかまで話せると、実運用を意識した回答になります。

まとめ

リアルタイム音声AIでは、モデル選定より先にパイプラインの形が効きます。

WebSocket で受けた音声をその場で await stt() する実装は簡単ですが、遅延が積み上がると戻ってきません。接続ごとの bounded queue、短い batch、明示的な drop policy、そして観測可能なメトリクスを最初から入れておくと、STT や LLM を差し替えても壊れにくい構成になります。

特にライブ用途では、「全部処理する」より「今に追いつく」ことが正解になる場面が多いです。そこを設計として説明できるかどうかが、デモ実装と実運用の分かれ目です。

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?