音声ストリーミングによりAIとの通話を実現する

電話の音声をそのままAIに聞かせ、AIが生成した音声をそのまま電話に返す —— NTT CPaaS の音声ストリーミング機能とお客様の自社開発リソースを組み合わせることによって、そのような双方向通信を実現できます。本記事では、サンプルソースコードを交えた実践シナリオをステップ・バイ・ステップで解説します。

はじめに

NTT CPaaSの「音声ストリーミング機能」を使用すると、電話の音声をリアルタイムで外部サービスに送受信できます。本機能とお客様側で構築するWebSocketサーバーおよびAIサービスを組み合わせることで、電話の発信者とAIによる双方向の音声通話を構成できます。

このチュートリアルでは、NTT CPaaSのAPIを用いた音声ストリーミングによるAI対話システムの構築方法を説明します。

音声ストリーミングでできること

従来のIVR(自動音声応答)は、ボタン操作やあらかじめ用意された短い音声認識シナリオによる分岐が中心であり、柔軟なリアルタイム対話には限界がありました。
一方、近年の音声対応AIモデルは双方向のリアルタイム会話に対応していますが、標準のインターフェースはWeb/アプリ向けのインターネット通信に限られ、通常の電話網とは直接接続できません。

NTT CPaaSの音声ストリーミング機能は、電話とAIの音声 をWebSocket経由でリアルタイムに送受信します。これにより、電話網とAIサービスの隔たりを解消し、電話機を用いた自然なAI対話システムを実現できます。

主な利用シーン

  • 電話問い合わせのAI自動一次応答
  • リアルタイム通話テキスト化とCRM自動連携
  • AI応答からオペレーターへのスムーズな通話転送

導入メリット

  • 従来のIVRを超える柔軟な会話展開

    あらかじめ決められたシナリオに依存せず、ユーザーの入力に合わせた自然な対話が可能になります。

  • 既存の電話網をそのまま活用可能

    ユーザー側に特別なアプリやブラウザを要求せず、既存の電話番号のままAI対話機能を提供できます。

前提知識・対象読者

本記事は、NTT CPaaSの Voice APIを活用したアプリケーションの構築を担当する開発者やシステムエンジニアを対象としています。

全体構成

本システムは以下の構成要素とフローで構成されます。

構成要素

  • エンドユーザー

    固定電話またはスマートフォンから指定番号へ通話発信を行います。

  • NTT CPaaS

    電話着信のハンドリング、Webhook通知、およびWebSocketへの音声ストリーミング転送を担当します。

  • お客様のシステム

    • Event Handler (Lambdaなど)

      NTT CPaaS からのイベント通知(Webhook)を受信し、応答・ダイアログ作成などの API リクエストを返します。

    • WebSocket Server (EC2など)

      NTT CPaaS および AI サービスとの間で WebSocket セッションを維持し、相互に音声を中継します。

    • AI サービス (OpenAI Realtime APIなど)

      WebSocket 経由で音声データを受信し、応答音声を生成して返送します。

フロー(通信の流れ)

まず、エンドユーザーが NTT CPaaS に対して通話発信をします。
NTT CPaaSは、エンドユーザーからの着信をはじめとした各種通話イベントを検知し、お客様のシステムの Event Handler に通知します。Event Handler は、受け取った通知の内容に応じて、通話をコントロールするための各種APIリクエストを NTT CPaaS へ送信します。

以上の処理が実行されることにより、下記の順序で通信をします。

  1. NTT CPaaS プラットフォームからお客様WebSocketサーバーへの通話発信
  2. お客様WebSocketサーバーとAIのセッション接続
  3. NTT CPaaS プラットフォームおよびWebSocketサーバーを経由したエンドユーザーと AI の音声送受信
  4. 脚注

事前準備・前提条件

Voice サービスのご利用開始

このチュートリアルを始めるには、NTT CPaaSアカウントが必要です。 こちらからログインをお願いします。またNTT CPaaS は、無料トライアルを用意していますが、本記事の実践シナリオを進めるためには、無料トライアルの提供対象外となる着信用番号が必須となります。詳細はお問い合わせいただくか、または無料トライアル申し込み後にマイページよりお申し込みください。

参照: トライアルの利用条件について
参照: 開発者ドキュメント > スタートアップガイド > Voice > サービス利用開始までの流れ

サービス開通後、以下参照を参考にAPIキーとベースURLを発行し、控えておいてください。
参照: 開発者ドキュメント > スタートアップガイド > ベースURLとAPIキー

APIキーのスコープ割り当て

発行したAPIキーに対して、本記事の実践シナリオを進めるために必要なスコープを割り当ててください。以下リファレンスを参考に、記載されているスコープを全体構成で示した各種APIキーに割り当ててください。

クラウドコンピューティングのアカウント取得

本記事の実践シナリオは、AWS環境での開発を前提にしています。
オンプレミス環境でも問題ございませんので、実践シナリオにおいて環境に言及する箇所がございましたら、適宜読み替えをしてください。
この事前準備によって、前述の 全体構成 で示した お客様のシステム エリア内リソースのうち、下記を開発可能な環境を整えることを想定しております。

  • Event Handler (NTT CPaaS からのWebhookイベント受信および NTT CPaaS へのAPIリクエスト送信が可能なもの)
  • WebSocket Server (WebSocketプロトコルに準じた双方向通信が可能なもの)

AIサービスのアカウント取得

本記事の実践シナリオは、OpenAI Realtime モデルを採用して動作確認をしています。
WebSocketプロトコルに準じた双方向通信をサポートしていれば、他のモデルでも実現可能な見込みがあります。
以上を勘案してAIサービスを選定して頂いた上、ご希望のアカウントを取得してください。

実践手順

本記事が目指すゴールは、音声通話によるエンドユーザーと AI の会話です。
前述の 全体構成 で示したとおり、エンドユーザーと AI の音声は複数のリソースを経由して送受信されます。
この実践シナリオでは、エンドユーザーに近いリソースからひとつずつ順番に疎通確認をし、ステップ・バイ・ステップで AI との疎通を目指します。
下記の3ステップを順番に達成することで、エンドユーザーと AI の会話成功を目指します。

  • Step 1: エンドユーザーから NTT CPaaS へ
  • Step 2: NTT CPaaS から WebSocket へ
  • Step 3: WebSocket から AI へ

前述の 全体構成 をふまえた上で、 Step 1 から 3 までの処理シーケンスを可視化したイメージは以下のとおりです。

Step 1: エンドユーザー から NTT CPaaS へ

1.Event Handler: 通話応答ロジック実装

リソース定義
ここで実装する Event Handler の処理内容は、Webhook受信に伴いAPIリクエストを1回送信するだけの短命なものであるため、サーバーレス・アプリケーション (API Gateway + Lambda) を採用します。具体的な実施事項と各事項の要点を以下に記します。

  1. 関数の追加 (Lambda)
    • ランタイム : Python3.12 (後述 コーディング のサンプルコードに採用しているため)
    • タイムアウト : 10 秒 (APIレスポンス待機時間を勘案してデフォルトの 3 秒よりも少し余裕をもたせた値)
  2. エンドポイントの追加 (API Gateway)
    ルート : POST /webhook (左記パスは本記事における暫定値であり読者の任意で変更可)
  3. エンドポイントと関数の紐付け
    • 追加したルートの統合先に 1 の関数を指定
    • デプロイ後に払い出されるURLを控えること (後続のシナリオで使用するため)
    • 例: https://{リソースID}.execute-api.{リージョン}.amazonaws.com/webhook
  4. 関数呼び出し権限の確認
    API Gateway から Lambda 関数を呼び出すために必要な実行許可 (lambda:InvokeFunction) が付与されていることを確認

コーディング

  1. Webhook受信ロジックの実装
    NTT CPaaS から Event Handler へ送信されるイベントWebhookをハンドリングするためのロジックを実装します。具体的には、Lambda エントリーポイントにて ”type”: “CALL_RECEIVED” を含むイベントを検知するための条件分岐処理をコーディングします。

    サンプルコードは下記のとおりです。
    import json
    import decimal
    
    def lambda_handler(event, context):
        try:
            # リクエストボディ取得
            event_body = json.loads(event.get('body', '{}'), parse_float=decimal.Decimal)
            # イベントタイプ取得
            event_type = event_body.get('type', '')
            # イベントタイプに応じた分岐処理
            match event_type:
                # 通話着信
                case 'CALL_RECEIVED':
                    pass # 後でコーディング
                # 上記以外
                case _:
                    pass
            # 戻り値返却
            return {
                'statusCode': 200,
                'headers': {'Content-Type': 'application/json'},
                'body': json.dumps({'message': 'There is no action to be taken.'})
            }
        except Exception as e:
            return {
                'statusCode': 500,
                'headers': {'Content-Type': 'application/json'},
                'body': json.dumps({'message': 'Internal server error', 'error': str(e)})
            }
  2. APIリクエスト送信ロジックの実装
    Event Handler から NTT CPaaS へ応答APIリクエストを送信するためのロジックを実装します。
    具体的には、”type”: “CALL_RECEIVED” を含むイベントを検知した後に、同APIのリファレンスに則した処理をコーディングをします。

    サンプルコードは下記のとおりです。
    import json
    import decimal
    import requests
    
    def lambda_handler(event, context):
        try:
            # リクエストボディ取得
            event_body = json.loads(event.get('body', '{}'), parse_float=decimal.Decimal)
            # イベントタイプ取得
            event_type = event_body.get('type', '')
            # イベントタイプに応じた分岐処理
            match event_type:
                # 通話着信
                case 'CALL_RECEIVED':
                    # URL取得
                    call_id = event_body.get('callId', '')
                    url = f"{ベースURL}/calls/1/calls/{call_id}/answer"
                    # ヘッダー取得
                    headers = {
                        'Authorization': f"App {APIキー}",
                        'Content-Type': 'application/json'
                    }
                    # ペイロード取得
                    payload = json.dumps({})
                    # 応答APIリクエスト送信
                    res = requests.post(url, headers=headers, data=payload)
                    # 戻り値フォーマット
                    response = {
                        'statusCode': res.status_code,
                        'headers': {'Content-Type': 'application/json'},
                        'body': res.text
                    }
                # 上記以外
                case _:
                    response = {
                        'statusCode': 200,
                        'headers': {'Content-Type': 'application/json'},
                        'body': json.dumps({'message': 'There is no action to be taken.'})
                    }
            # 戻り値返却
            return response
        except Exception as e:
            return {
                'statusCode': 500,
                'headers': {'Content-Type': 'application/json'},
                'body': json.dumps({'message': 'Internal server error', 'error': str(e)})
            }
  3. 関数のデプロイ

    実装した関数ソースコードをデプロイします。
    その際には、関数内で利用している外部ライブラリ (前述のサンプルコードでは requests) を含めるか、またはLambdaレイヤーとして個別にアップロードをしてください。

2.NTT CPaaS プラットフォーム設定

通話設定の追加
コールAPI構成ページ (要ログイン) にて 通話設定を作成 ボタンをクリックし、設定を追加してください。
具体的な入力項目と値は以下のとおりです。

  • 通話設定ID : 任意の値を入力
  • 通話設定名 : 任意の値を入力 (省略可)

前項のうち 通話設定ID は後続のシナリオで利用するため控えておいてください。

この設定に関する詳細は、下記の製品ドキュメントをご参照ください。
Voice と WebRTC > Calls API プラットフォームを理解する > 呼び出し API とは > コール設定の作成

配信登録 (サブスクリプション) の追加
配信登録管理 ページ (要ログイン) にて 配信登録を作成 ボタンをクリックし、配信登録を追加してください。
具体的な入力項目と値は以下のとおりです。

  • サブスクリプション名 : 任意の値を入力
  • チャネル : Voice および WebRTC を選択
  • イベントの選択 : 通話受信 を選択
  • 通話構成 : 前述の 通話設定の追加 において入力した 通話設定ID を選択
  • 通知プロファイル : 通知プロファイルを新規作成 を選択
  • 通知プロファイルの名前 : 任意の値を入力
  • Webhook URL : 前述の 3. エンドポイントと関数の紐付け において控えた Event Handler のURLを入力

この設定に関する詳細は、下記の製品ドキュメントをご参照ください。
Webhook サブスクリプション

番号インバウンド構成の追加
番号ぺージ (要ログイン) にて 対象番号 > 音声 > インバウンド構成 の編集ボタン (鉛筆アイコン) をクリックし、構成を設定してください。
具体的な入力項目と値は以下のとおりです。

  • 転送アクション : サブスクリプションに転送 を選択
  • 通話設定 : 前述の 通話設定の追加 において入力した 通話設定ID を選択

この設定に関する詳細は、下記の製品ドキュメントをご参照ください。
Voice と WebRTC > Calls API プラットフォームを理解する > 呼び出し API とは > 番号

3.疎通確認

前述の 事前準備 で用意した電話機から対象番号へ通話を発信してください。
発信から数秒経過した後、電話機の画面表示が通話中に切り替われば、本ステップは完了です。
尚、この段階では、通話中に切り替わった後も音声は流れません。無音のまま通話時間がカウントアップするのが正常な状態です。音声が流れるようになるのは次の Step 2 からです。

補足
通話発信後から通話中に切り替わるまでの間、一般的な電話で聴くことのできる「プルルルル…」という呼び出し音は鳴りません。
もし呼び出し音を鳴らしたい場合は、呼び出し音の送信APIをリクエストしてください。

ただし、本記事の通信を実現するために必須のリクエストではございません。

Step 2: NTT CPaaS から WebSocket へ

1.WebSocket Server: 初期構築

リソース定義
ここで実装する WebSocket Server は、NTT CPaaS と AI の橋渡しとなって音声を送受信し続ける必要があるため、仮想サーバー上の常駐プロセスとして動かし、かつセキュリティを維持するために必要なネットワークを設定します。以上をふまえて推奨する定義内容は以下のとおりです。

  1. 仮想サーバー (EC2)
    • インスタンスタイプ : t2.micro
    • OS : Ubuntu 22.04
    • セキュリティグループ : 下記のポート番号を許容するインバウンドルールを追加
      ・80 : 証明書取得および更新
      ・443 : WSS通信
  2. ネットワーク (VPC / Route53)
    • サーバーIPアドレスの固定化
    • DNSレコード : 前項のIPアドレスと紐付けるAレコードを追加
      例: stream.yourdomain.com

コーディング

  1. WebSocketセッション制御ロジックの実装
    NTT CPaaS からの通話発信、即ちWSS接続要求に応答し、受信した音声をそのまま送信 (オウム返し) する処理モジュール app.js を実装します。
    具体的には、後述の 初期化スクリプトの実装 のリバースプロキシで指定するポート 3000 で待機し、バイナリタイプのメッセージを検知したらそのままの内容を送り返します。

    サンプルコードは下記のとおりです。
    // モジュール宣言
    const ws = require('ws');
    // 定数宣言
    const PORT = 3000;
    // WebSocketクラス初期化
    const wss = new ws.Server({ port: PORT });
    // ログ出力
    console.log(`WebSocket server running on port ${PORT}`);
    // NTT CPaaS 接続に伴う処理の実行
    wss.on('connection', (nttCpaasWs) => handleNttCpaasWs(nttCpaasWs));
    
    // NTT CPaaS 接続に伴う処理の定義
    const handleNttCpaasWs = async (nttCpaasWs) => {
        // ログ出力
        console.log('[NTT CPaaS] Client connected.');
        // NTT CPaaS メッセージ受信に伴う処理の実行
        nttCpaasWs.on('message', message => handleNttCpaasWsMessage(nttCpaasWs, message));
        // NTT CPaaS 接続終了に伴う処理の実行
        nttCpaasWs.on('close', () => handleNttCpaasWsClose(nttCpaasWs));
        // NTT CPaaS 接続エラーに伴う処理の実行
        nttCpaasWs.on('error', error => console.error('[NTT CPaaS] WebSocket error:', error));
    }
    
    // NTT CPaaS メッセージ受信に伴う処理の定義
    const handleNttCpaasWsMessage = async (nttCpaasWs, message) => {
        // 正常系
        try {
            // 受信したメッセージの解析処理の実行
            const result = parseNttCpaasWsMessage(message);
            // 解析結果に応じた分岐処理
            switch (result.type) {
                // JSONの時
                case 'json':
                    // ログ出力
                    console.log('[NTT CPaaS] WebSocket event received:', result.content);
                    break;
                // バイナリの時
                case 'binary':
                    // NTT CPaaSへのデータ送信 (オウム返し)
                    nttCpaasWs.send(result.content);
                    break;
                // 上記以外の時
                default:
                    // 型例外スロー
                    throw new TypeError('[NTT CPaaS] Received unexpected message type.');
            }
        // 異常系
        } catch (error) {
            // ログ出力
            console.error(`Caught exception: error.name = ${error.name}, error.message = ${error.message}`);
        }
    }
    
    // NTT CPaaS 接続終了に伴う処理の定義
    const handleNttCpaasWsClose = async (nttCpaasWs) => {
        // ログ出力
        console.log('[NTT CPaaS] Client closed.');
    }
    
    // NTT CPaaS メッセージ解析処理の定義
    const parseNttCpaasWsMessage = (message) => {
        // 正常系
        try {
            // メッセージのJSON解析実行
            const parseData = JSON.parse(message);
            return { type: 'json', content: parseData };
        // 異常系: メッセージのJSON解析に失敗した時
        } catch (e) {
            // 解析対象メッセージがバイナリデータの時
            if (message instanceof Buffer) {
                return { type: 'binary', content: message };
            // 解析対象メッセージがバイナリデータ以外の時
            } else {
                return { type: 'others', content: message };
            }
        }
    }
  2. 依存関係管理ファイルの作成
    前章のロジックで利用する外部ライブラリを依存関係管理ファイル package.json で定義します。

    サンプルコードは下記のとおりです。
    {
      "name": "websocket-sample",
      "version": "1.0.0",
      "main": "app.js",
      "dependencies": {
        "ws": "^8.0.0"
      }
    }
  3. 初期化スクリプトの実装

    仮想サーバー起動時に実行する初期化スクリプト (ユーザーデータ) を実装します。
    具体的には、以下のコンポーネントを導入/実行する命令を記述します。

    • リバースプロキシ : Nginx
    • 証明書取得および更新 : Certbot
    • サーバー実行環境 : Node.js
    • プロセスマネージャ : PM2
    • その他 : ここまでに実装した app.js および package.json の作成
    サンプルコードは下記のとおりです。
    #!/bin/bash
    set -eux
    
    # --------------------------------------------------
    # パラメータ定義
    # --------------------------------------------------
    DOMAIN_NAME="stream.yourdomain.com"
    CERT_EMAIL="admin@yourdomain.com"
    APP_DIR="/var/www/websocket-app"
    SERVER_USER="ubuntu"
    
    # --------------------------------------------------
    # 必須パッケージ & Node.js インストール
    # --------------------------------------------------
    apt-get update -y
    apt-get install -y curl git jq
    # NodeSource より Node.js 20.x リポジトリを追加してインストール
    curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
    DEBIAN_FRONTEND=noninteractive apt-get install -y nodejs nginx certbot python3-certbot-nginx
    
    # --------------------------------------------------
    # リバースプロキシ設定 (Nginx)
    # --------------------------------------------------
    cat > /etc/nginx/sites-available/${DOMAIN_NAME}.conf <<EOF
    server {
        listen 80;
        server_name ${DOMAIN_NAME};
        location / {
            proxy_pass http://localhost:3000;
            # WebSocket ヘッダー転送設定
            proxy_http_version 1.1;
            proxy_set_header Upgrade \$http_upgrade;
            proxy_set_header Connection "Upgrade";
            # クライアント識別用ヘッダー
            proxy_set_header Host \$host;
            proxy_set_header X-Real-IP \$remote_addr;
            proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto \$scheme;
        }
    }
    EOF
    # 設定ファイルの有効化と Nginx 再起動
    ln -sf /etc/nginx/sites-available/${DOMAIN_NAME}.conf /etc/nginx/sites-enabled/
    nginx -t
    systemctl restart nginx
    
    # --------------------------------------------------
    # 証明書取得および自動更新 (Certbot)
    # --------------------------------------------------
    # Let's Encrypt SSL証明書の取得
    certbot --nginx -d ${DOMAIN_NAME} --non-interactive --agree-tos --email ${CERT_EMAIL} || true
    
    # --------------------------------------------------
    # WebSocket アプリケーションの作成
    # --------------------------------------------------
    mkdir -p ${APP_DIR}
    cd ${APP_DIR}
    # 依存関係管理ファイルの作成 & ファイルに基づくインストール
    cat > package.json <<'EOF'
    # 前述 package.json の内容を記載
    EOF
    npm install
    # 処理モジュールの作成
    cat > app.js <<'EOF'
    # 前述 app.js の内容を記載
    EOF
    # アプリ実行ユーザーに対するディレクトリへの権限付与
    chown -R ${SERVER_USER}:${SERVER_USER} ${APP_DIR}
    
    # --------------------------------------------------
    # プロセスマネージャーによる起動 & 永続化 (PM2)
    # --------------------------------------------------
    npm install -g pm2
    # 一般ユーザー権限で PM2 プロセスを起動
    sudo -i -u ${SERVER_USER} bash <<EOF
    cd ${APP_DIR}
    pm2 start app.js --name "websocket-server"
    pm2 save
    EOF
    # OS起動時に PM2 を自動復旧する systemd 設定の有効化
    env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ${SERVER_USER} --hp /home/${SERVER_USER}

2.NTT CPaaS プラットフォーム設定

メディアストリーミング設定の追加
メディアストリーミング ページ (要ログイン) にて メディアストリーミング設定を作成 ボタンをクリックし、設定を追加してください。
具体的な入力項目と値は以下のとおりです。

  • タイプ (画面冒頭) : WebSocketエンドポイント を選択
  • 名前 : 任意の値を入力
  • URL : 前述の WebSocket Server: 初期構築 に伴い決定した WebSocket Server のURLを入力

追加に伴い画面上のリストに表示されるID (メディアストリーム設定ID) は後続のシナリオで利用するため控えておいてください。

この設定に関する詳細は、下記の製品ドキュメントをご参照ください。
Voice と WebRTC > WebSocket ストリーミングを使用する

配信登録 (サブスクリプション) の編集
配信登録管理 ページ (要ログイン) にて追加済配信登録の編集ページにアクセスし、以下のとおり入力してください。
イベントの選択 : 通話確立 を選択 (*既に選択している 通話受信 はそのまま維持)

3.Event Handler: 通話発信ロジック実装

コーディング

  1. Webhook受信ロジックの実装 (追加)
    NTT CPaaS から Event Handler へ送信されるイベント Webhook をハンドリングするためのロジックを実装します。
    具体的には、Lambda エントリーポイントにて ”type”: ”CALL_ESTABLISHED” を含むイベントを検知するための条件分岐処理をコーディングします。

    サンプルコードは下記のとおりです。
    import json
    import decimal
    import requests
    
    def lambda_handler(event, context):
        try:
            # リクエストボディ取得
            event_body = json.loads(event.get('body', '{}'), parse_float=decimal.Decimal)
            # イベントタイプ取得
            event_type = event_body.get('type', '')
            # イベントタイプに応じた分岐処理
            match event_type:
                # 通話着信
                case 'CALL_RECEIVED':
                    # URL取得
                    call_id = event_body.get('callId', '')
                    url = f"{ベースURL}/calls/1/calls/{call_id}/answer"
                    # ヘッダー取得
                    headers = {
                        'Authorization': f"App {APIキー}",
                        'Content-Type': 'application/json'
                    }
                    # ペイロード取得
                    payload = json.dumps({})
                    # 応答APIリクエスト送信
                    res = requests.post(url, headers=headers, data=payload)
                    # 戻り値フォーマット
                    response = {
                        'statusCode': res.status_code,
                        'headers': {'Content-Type': 'application/json'},
                        'body': res.text
                    }
                # 通話着信
                case 'CALL_ESTABLISHED':
                    pass # 後でコーディング
                # 上記以外
                case _:
                    response = {
                        'statusCode': 200,
                        'headers': {'Content-Type': 'application/json'},
                        'body': json.dumps({'message': 'There is no action to be taken.'})
                    }
            # 戻り値返却
            return response
        except Exception as e:
            return {
                'statusCode': 500,
                'headers': {'Content-Type': 'application/json'},
                'body': json.dumps({'message': 'Internal server error', 'error': str(e)})
            }
  2. APIリクエスト送信ロジックの実装 (追加)
    Event Handler から NTT CPaaS へ ダイアログの作成 APIリクエストを送信するためのロジックを実装します。
    具体的には、”type”: “CALL_ESTABLISHED” を含むイベントを検知した後に、同APIのリファレンスに則した処理をコーディングをします。

    サンプルコードは下記のとおりです。
    import json
    import decimal
    import requests
    
    def lambda_handler(event, context):
        try:
            # リクエストボディ取得
            event_body = json.loads(event.get('body', '{}'), parse_float=decimal.Decimal)
            # イベントタイプ取得
            event_type = event_body.get('type', '')
            # イベントタイプに応じた分岐処理
            match event_type:
                # 通話着信
                case 'CALL_RECEIVED':
                    # URL取得
                    call_id = event_body.get('callId', '')
                    url = f"{ベースURL}/calls/1/calls/{call_id}/answer"
                    # ヘッダー取得
                    headers = {
                        'Authorization': f"App {APIキー}",
                        'Content-Type': 'application/json'
                    }
                    # ペイロード取得
                    payload = json.dumps({})
                    # 応答APIリクエスト送信
                    res = requests.post(url, headers=headers, data=payload)
                    # 戻り値フォーマット
                    response = {
                        'statusCode': res.status_code,
                        'headers': {'Content-Type': 'application/json'},
                        'body': res.text
                    }
                # 通話確立
                case 'CALL_ESTABLISHED':
                    # URL取得
                    url = f"{ベースURL}/calls/1/dialogs"
                    # ヘッダー取得
                    headers = {
                        'Authorization': f"App {APIキー}",
                        'Content-Type': 'application/json'
                    }
                    # ペイロード取得
                    parent_call_id = event_body.get('callId', '')
                    payload = json.dumps({
                        'parentCallId': parent_call_id,
                        'childCallRequest': {
                            'endpoint': {
                                'type': 'WEBSOCKET',
                                'websocketEndpointConfigId': '{メディアストリーム設定ID}'
                            }
                        }
                    })
                    # ダイアログ作成APIリクエスト送信
                    res = requests.post(url, headers=headers, data=payload)
                    # 戻り値フォーマット
                    response = {
                        'statusCode': res.status_code,
                        'headers': {'Content-Type': 'application/json'},
                        'body': res.text
                    }
                # 上記以外
                case _:
                    response = {
                        'statusCode': 200,
                        'headers': {'Content-Type': 'application/json'},
                        'body': json.dumps({'message': 'There is no action to be taken.'})
                    }
            # 戻り値返却
            return response
        except Exception as e:
            return {
                'statusCode': 500,
                'headers': {'Content-Type': 'application/json'},
                'body': json.dumps({'message': 'Internal server error', 'error': str(e)})
            }
  3. 関数のデプロイ
    実装した関数ソースコードをデプロイします。

4.疎通確認

前述の Step 1 と同様に、対象番号へ通話を発信して通話中に切り替わることを確認してください。
通話中に切り替わってから数秒経過した後、電話機のマイクに向かって発声してください。
発声した直後に電話機のスピーカーから自分の音声がそのまま聴こえてきたら、本ステップは完了です。

Step 3: WebSocket から AI へ

1.AIプラットフォーム設定

APIキー作成
OpenAIプラットフォームにてAPIキーを作成してください。
作成したことに伴い表示されるシークレットキーは、後続のシナリオで利用するため控えておいてください。
参照 : Developer quickstart | OpenAI API

2.NTT CPaaS プラットフォーム設定

メディアストリーミング設定の編集
メディアストリーミング ページ (要ログイン) にて追加済設定の編集ページにアクセスし、以下のとおり入力してください。

・サンプリングレート : 24000 を選択

上記の値は NTT CPaaS と OpenAI の両方でサポートする値として採用するものです。
詳細は以下の比較表を参照してください。
参考 : 入出力音声仕様のサポート比較表

比較対象サービス フォーマット サンプリングレート 参考サイト
NTT CPaaS PCMのみサポート 下記から選択可
・8kHz
・16kHz
・24kHz
・32kHz
WebSocket ストリーミングを使用する > WebSocket メッセージ
OpenAI 下記から選択可
・PCM
・G.711 μ-law
・G.711 A-law
・PCMの場合は 24kHz のみ指定可
・前項以外は指定不可
 Realtime client events | OpenAI API Reference > session.update

2.WebSocket Server: AIとの接続

コーディング

AIセッション制御ロジックの実装
前ステップで実装した「オウム返し」処理を改修し、NTT CPaaS とOpenAIとの間で双方向に音声データを橋渡しするロジックを実装します。
具体的には、NTT CPaaS からの接続確立 (connection) を検知したタイミングで OpenAI Realtime API とのWebSocket接続を開始し、AIへの指示内容等を含めたセッションの初期化 (session.update) を行います。
通話中の音声処理については、NTT CPaaS から受信したバイナリの音声データをBase64エンコードしてOpenAIへ送信(input_audio_buffer.append) する処理へと置き換えます。

さらに、エンドユーザーが割り込んで話し始めたこと (input_audio_buffer.speech_started) をOpenAIが検知した際は、AIの発話を即座に中断させるため、NTT CPaaS にバッファクリアコマンド ({ action: 'clear' }) を送信する制御も実装します。

サンプルコードは下記のとおりです。
// モジュール宣言
const ws = require('ws');
// 定数宣言
const PORT = 3000;

//----------------------------------------------------------------------
// NTT CPaaS side 制御ロジック
//----------------------------------------------------------------------

// WebSocketクラス初期化
const wss = new ws.Server({ port: PORT });
// ログ出力
console.log(`WebSocket server running on port ${PORT}`);
// NTT CPaaS 接続に伴う処理の実行
wss.on('connection', (nttCpaasWs) => handleNttCpaasWs(nttCpaasWs));

// NTT CPaaS 接続に伴う処理の定義
const handleNttCpaasWs = async (nttCpaasWs) => {
    // ログ出力
    console.log('[NTT CPaaS] Client connected.');
    // OpenAIとの接続セットアップ処理の実行
    setupOpenAIWs(nttCpaasWs);
    // NTT CPaaS メッセージ受信に伴う処理の実行
    nttCpaasWs.on('message', message => handleNttCpaasWsMessage(nttCpaasWs, message));
    // NTT CPaaS 接続終了に伴う処理の実行
    nttCpaasWs.on('close', () => handleNttCpaasWsClose(nttCpaasWs));
    // NTT CPaaS 接続エラーに伴う処理の実行
    nttCpaasWs.on('error', error => console.error('[NTT CPaaS] WebSocket error:', error));
}

// NTT CPaaS メッセージ受信に伴う処理の定義
const handleNttCpaasWsMessage = async (nttCpaasWs, message) => {
    // 正常系
    try {
        // 受信したメッセージの解析処理の実行
        const result = parseNttCpaasWsMessage(message);
        // 解析結果に応じた分岐処理
        switch (result.type) {
            // JSONの時
            case 'json':
                // ログ出力
                console.log('[NTT CPaaS] WebSocket event received:', result.content);
                break;
            // バイナリの時
            case 'binary':
                // OpenAIへのデータ送信
                if (nttCpaasWs.openAiWs && nttCpaasWs.openAiWs.readyState === ws.OPEN) {
                    const audioMessage = {
                        type: 'input_audio_buffer.append',
                        audio: result.content.toString('base64')
                    };
                    nttCpaasWs.openAiWs.send(JSON.stringify(audioMessage));
                }
                break;
            // 上記以外の時
            default:
                // 型例外スロー
                throw new TypeError('[NTT CPaaS] Received unexpected message type.');
        }
    // 異常系
    } catch (error) {
        // ログ出力
        console.error(`Caught exception: error.name = ${error.name}, error.message = ${error.message}`);
    }
}

// NTT CPaaS 接続終了に伴う処理の定義
const handleNttCpaasWsClose = async (nttCpaasWs) => {
    // ログ出力
    console.log('[NTT CPaaS] Client closed.');
    // OpenAI 接続終了
    if (nttCpaasWs.openAiWs) nttCpaasWs.openAiWs.close();
}

// NTT CPaaS メッセージ解析処理の定義
const parseNttCpaasWsMessage = (message) => {
    // 正常系
    try {
        // メッセージのJSON解析実行
        const parseData = JSON.parse(message);
        return { type: 'json', content: parseData };
    // 異常系: メッセージのJSON解析に失敗した時
    } catch (e) {
        // 解析対象メッセージがバイナリデータの時
        if (message instanceof Buffer) {
            return { type: 'binary', content: message };
        // 解析対象メッセージがバイナリデータ以外の時
        } else {
            return { type: 'others', content: message };
        }
    }
}

//----------------------------------------------------------------------
// OpenAI side 制御ロジック
//----------------------------------------------------------------------

// OpenAIとの接続セットアップ処理の定義
const setupOpenAIWs = async (nttCpaasWs) => {
    // 正常系
    try {
        // OpenAI Realtime API 接続セッション初期化
        const OPENAI_WSS_URL = 'wss://api.openai.com/v1/realtime?model={モデル名}';
        const OPENAI_API_KEY = '{APIキー}';
        const OPENAI_WSS_OPTION = {
            headers: {
                Authorization: `Bearer ${OPENAI_API_KEY}`,
            },
        }
        const openAiWs = new ws.WebSocket(OPENAI_WSS_URL, OPENAI_WSS_OPTION);
        // OpenAI 接続セッション取得
        nttCpaasWs.openAiWs = openAiWs;
        // OpenAI 接続開始に伴う処理の実行
        openAiWs.on('open', () => handleOpenAiWsOpen(openAiWs));
        // OpenAI メッセージ受信に伴う処理の実行
        openAiWs.on('message', data => handleOpenAiMessage(nttCpaasWs, data));
        // OpenAI 接続終了に伴う処理の実行
        openAiWs.on('close', () => console.log('[OpenAI] Client closed.'));
        // OpenAI 接続エラーに伴う処理の実行
        openAiWs.on('error', error => console.error('[OpenAI] WebSocket error:', error));
    // 異常系
    } catch (error) {
        // ログ出力
        console.error('[OpenAI] Setup error:', error);
    }
};

// OpenAI 接続開始に伴う処理の定義
const handleOpenAiWsOpen = async (openAiWs) => {
    // 接続セッションの設定更新
    console.log('[OpenAI] Client connected.');
    const sessionUpdateMessage = {
        type: 'session.update',
        session: {
            type: 'realtime',
            audio: {
                input: {
                    format: {
                        type: 'audio/pcm'
                    }
                },
                output: {
                    format: {
                        type: 'audio/pcm'
                    }
                }
            },
            instructions: 'あなたは技術的な問題の解決を支援するエンジニアです。'
        }
    };
    openAiWs.send(JSON.stringify(sessionUpdateMessage));
};

// OpenAI メッセージ受信に伴う処理の定義
const handleOpenAiMessage = async (nttCpaasWs, data) => {
    try {
        const message = JSON.parse(data);
        switch (message.type) {
            // 音声入力開始
            case 'input_audio_buffer.speech_started':
                // NTT CPaaS 側のバッファへ送信したOpenAI音声データのクリア
                nttCpaasWs.send(JSON.stringify({ action: 'clear' }));
                break;
            // 音声バイト配信
            case 'response.output_audio.delta':
                // OpenAI音声データを NTT CPaaS へ送信
                const buffRaw = Buffer.from(message.delta, 'base64');
                nttCpaasWs.send(buffRaw);
                break;
            // エラー
            case 'error':
                console.log('[OpenAI] Error occurred.');
                console.log('[OpenAI] - event_id:', message.event_id);
                console.log('[OpenAI] - error:', JSON.stringify(message.error, null, 2));
                break;
            // 上記以外
            default:
                break;
        }
    } catch (error) {
        console.error('[OpenAI] Error processing message:', error);
    }
}

3.疎通確認

前述の Step 1 と同様に、対象番号へ通話を発信して通話中に切り替わることを確認してください。
通話中に切り替わってから数秒経過した後、電話機のマイクに向かって発声してください。
発声してから間もなくAIの音声が聴こえてきたら、本ステップは完了です。

まとめ

従来のIVRでは実現が難しかった「リアルタイムで自然な会話展開」も、NTT CPaaS が電話とお客様のWebSocketサーバーを橋渡しし、更にAIプラットフォームと接続することで、シームレスな双方向通信として実現できることがお分かりいただけたかと思います。実践シナリオでご紹介した3つのステップに沿って段階的に疎通確認を行うことで、複雑に見える構成も着実に構築することが可能です。

ビジネスへの応用と展望

今回構築した仕組みは、単なる技術的な検証にとどまりません。冒頭でお伝えしたような「電話対応のAIによる一次受付」や「オペレーターへのスムーズな転送」、「リアルタイムな文字起こしとCRM連携」といった、実際のビジネス課題を解決するための強力な基盤となります。ここから先は、AIのプロンプトをチューニングして自社のブランドイメージに合ったトーンで会話させたり、自社データベースと連携させて「顧客の過去の履歴に応じたパーソナライズ対応」を実現したりすることで、更に高度なソリューションへと発展させることができます。

関連ドキュメント

NTT CPaaSを、
60日間無料でお試しください

・SMS・Voice・メールを本番同様に無料で検証
・全API機能に即日アクセス / 有料プランと同一環境
・国内開発者向けに最適化された日本語ガイド

無料トライアル

目次
  1. はじめに
  2. 音声ストリーミングでできること
    1. 主な利用シーン
    2. 導入メリット
  3. 前提知識・対象読者
  4. 全体構成
    1. 構成要素
    2. フロー(通信の流れ)
    3. 脚注
  5. 事前準備・前提条件
    1. Voice サービスのご利用開始
    2. APIキーのスコープ割り当て
    3. クラウドコンピューティングのアカウント取得
    4. AIサービスのアカウント取得
  6. 実践手順
    1. Step 1: エンドユーザー から NTT CPaaS へ
      1. 1.Event Handler: 通話応答ロジック実装
      2. 2.NTT CPaaS プラットフォーム設定
      3. 3.疎通確認
    2. Step 2: NTT CPaaS から WebSocket へ
      1. 1.WebSocket Server: 初期構築
      2. 2.NTT CPaaS プラットフォーム設定
      3. 3.Event Handler: 通話発信ロジック実装
      4. 4.疎通確認
    3. Step 3: WebSocket から AI へ
      1. 1.AIプラットフォーム設定
      2. 2.NTT CPaaS プラットフォーム設定
      3. 3.疎通確認
  7. まとめ
  8. ビジネスへの応用と展望
  9. 関連ドキュメント

2026.10.21