ChatGPT × VOICEVOXを連携させてAI音声会話ボットを作る方法【2026年最新】Pythonコード付き完全解説

pip install openai requests pyaudio

# Mac（Homebrewが入っている場合）
brew install portaudio
pip install pyaudio

# ①テキストから音声合成クエリを生成
curl -s -X POST "127.0.0.1:50021/audio_query?speaker=1" \
    --get --data-urlencode text@text.txt > query.json

# ②クエリから音声ファイルを生成（サンプリングレート24000Hz）
curl -s -H "Content-Type: application/json" \
    -X POST -d @query.json \
    "127.0.0.1:50021/synthesis?speaker=1" > audio.wav

import os
import json
import requests
import pyaudio
import wave
import io
from openai import OpenAI

# --- 設定 ---
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "your-api-key-here")
VOICEVOX_URL = "http://127.0.0.1:50021"
SPEAKER_ID = 3  # ずんだもん（ノーマル）
MODEL = "gpt-5.4-mini"  # GPT-5.4 miniを使用

client = OpenAI(api_key=OPENAI_API_KEY)

def chat_with_gpt(user_message: str, conversation_history: list) -> str:
    conversation_history.append({"role": "user", "content": user_message})
    response = client.chat.completions.create(
        model=MODEL,
        messages=conversation_history,
        max_tokens=500
    )
    assistant_message = response.choices[0].message.content
    conversation_history.append({"role": "assistant", "content": assistant_message})
    return assistant_message

def text_to_speech_voicevox(text: str, speaker: int = SPEAKER_ID) -> bytes:
    # ステップ1: 音声合成クエリの生成
    query_response = requests.post(
        f"{VOICEVOX_URL}/audio_query",
        params={"speaker": speaker, "text": text}
    )
    query_response.raise_for_status()
    audio_query = query_response.json()
    audio_query["speedScale"] = 1.1  # 少し速めに

    # ステップ2: 音声ファイルの生成
    synthesis_response = requests.post(
        f"{VOICEVOX_URL}/synthesis",
        params={"speaker": speaker},
        headers={"Content-Type": "application/json"},
        data=json.dumps(audio_query)
    )
    synthesis_response.raise_for_status()
    return synthesis_response.content

def play_audio(wav_bytes: bytes):
    wav_file = wave.open(io.BytesIO(wav_bytes))
    p = pyaudio.PyAudio()
    stream = p.open(
        format=p.get_format_from_width(wav_file.getsampwidth()),
        channels=wav_file.getnchannels(),
        rate=wav_file.getframerate(),
        output=True
    )
    chunk = 1024
    data = wav_file.readframes(chunk)
    while data:
        stream.write(data)
        data = wav_file.readframes(chunk)
    stream.stop_stream()
    stream.close()
    p.terminate()
    wav_file.close()

def main():
    system_prompt = "あなたは親切なアシスタントです。回答は100文字以内にしてください。音声読み上げ用なので記号や絵文字は使わないでください。"
    conversation_history = [{"role": "system", "content": system_prompt}]

    print("ChatGPT x VOICEVOX 音声会話ボット")
    print("終了するには quit と入力してください")

    while True:
        user_input = input("あなた: ").strip()
        if user_input.lower() == "quit":
            break
        if not user_input:
            continue
        reply = chat_with_gpt(user_input, conversation_history)
        print(f"ChatGPT: {reply}")
        wav_data = text_to_speech_voicevox(reply)
        play_audio(wav_data)

if __name__ == "__main__":
    main()

# macOS / Linux
export OPENAI_API_KEY="sk-xxxxxxxxxxxx"
python3 voicevox_chatgpt.py

import requests

def get_speakers():
    response = requests.get("http://127.0.0.1:50021/speakers")
    speakers = response.json()
    for speaker in speakers:
        print(f"■ {speaker['name']}")
        for style in speaker['styles']:
            print(f"  - {style['name']} : ID={style['id']}")

get_speakers()

def generate_dialogue(topic: str):
    """2キャラクターで指定トピックについて掛け合いを生成する"""
    system_prompt = """次のトピックについて、2人のキャラクターが話すセリフを生成してください。
形式：キャラA: セリフ / キャラB: セリフ（各50文字以内、記号なし）"""

    response = client.chat.completions.create(
        model="gpt-5.4-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": topic}
        ]
    )

    dialogue_text = response.choices[0].message.content
    for line in dialogue_text.strip().split("\n"):
        if line.startswith("キャラA:"):
            text = line.replace("キャラA:", "").strip()
            speaker_id = 2  # 四国めたん
        elif line.startswith("キャラB:"):
            text = line.replace("キャラB:", "").strip()
            speaker_id = 3  # ずんだもん
        else:
            continue
        if text:
            wav = text_to_speech_voicevox(text, speaker=speaker_id)
            play_audio(wav)

import time

def text_to_speech_voicevox_safe(text: str, speaker: int = SPEAKER_ID) -> bytes | None:
    """エラーハンドリング付きのVOICEVOX音声合成"""
    if not text or not text.strip():
        return None

    try:
        query_response = requests.post(
            f"{VOICEVOX_URL}/audio_query",
            params={"speaker": speaker, "text": text},
            timeout=10  # タイムアウト設定
        )
        query_response.raise_for_status()
        audio_query = query_response.json()
        audio_query["speedScale"] = 1.1

        synthesis_response = requests.post(
            f"{VOICEVOX_URL}/synthesis",
            params={"speaker": speaker},
            headers={"Content-Type": "application/json"},
            data=json.dumps(audio_query),
            timeout=30
        )
        synthesis_response.raise_for_status()
        return synthesis_response.content

    except requests.exceptions.ConnectionError:
        print("[ERROR] VOICEVOXに接続できません。VOICEVOXが起動しているか確認してください。")
        return None
    except requests.exceptions.Timeout:
        print("[ERROR] VOICEVOXとの通信がタイムアウトしました。")
        return None
    except requests.exceptions.HTTPError as e:
        print(f"[ERROR] VOICEVOX APIエラー: {e}")
        return None

def chat_with_gpt_safe(user_message: str, conversation_history: list) -> str | None:
    """エラーハンドリング付きのChatGPT API呼び出し"""
    try:
        conversation_history.append({"role": "user", "content": user_message})
        response = client.chat.completions.create(
            model=MODEL,
            messages=conversation_history,
            max_tokens=500,
            timeout=30
        )
        assistant_message = response.choices[0].message.content
        conversation_history.append({"role": "assistant", "content": assistant_message})
        return assistant_message
    except Exception as e:
        print(f"[ERROR] ChatGPT APIエラー: {e}")
        # エラーが出た場合は最後のユーザーメッセージを履歴から削除
        if conversation_history and conversation_history[-1]["role"] == "user":
            conversation_history.pop()
        return None

import time
from openai import RateLimitError

def chat_with_retry(user_message: str, conversation_history: list, max_retries: int = 3) -> str | None:
    """レート制限対応のリトライ付きChatGPT API呼び出し"""
    for attempt in range(max_retries):
        result = chat_with_gpt_safe(user_message, conversation_history)
        if result is not None:
            return result
        if attempt < max_retries - 1:
            wait_time = (attempt + 1) * 5  # 5秒、10秒、15秒と段階的に待つ
            print(f"リトライ待機中... ({wait_time}秒)")
            time.sleep(wait_time)
    return None

# ナレーション用（落ち着いた読み上げ）
NARRATION_PARAMS = {
    "speedScale": 0.95,
    "pitchScale": -0.02,
    "intonationScale": 0.85,
    "volumeScale": 1.0
}

# チャットボット用（元気でフレンドリー）
CHATBOT_PARAMS = {
    "speedScale": 1.1,
    "pitchScale": 0.0,
    "intonationScale": 1.2,
    "volumeScale": 1.0
}

# ニュース読み上げ用（明瞭で聞き取りやすい）
NEWS_PARAMS = {
    "speedScale": 1.0,
    "pitchScale": -0.01,
    "intonationScale": 0.9,
    "volumeScale": 1.1
}

def apply_voice_params(audio_query: dict, params: dict) -> dict:
    """音声パラメータを適用する"""
    audio_query.update(params)
    return audio_query

def generate_narration_script(topic: str) -> str:
    """トピックからYouTube動画の台本を生成する"""
    response = client.chat.completions.create(
        model="gpt-5.4-mini",
        messages=[{
            "role": "user",
            "content": f"""以下のトピックについて、YouTube動画の台本を生成してください。
            
トピック: {topic}

要件:
- 3〜5分程度（文字数1000〜1500字）
- 音声読み上げ向けなので句読点を多め、記号は使わない
- 導入・本編・まとめの構成で
- 語り口はカジュアルかつ知的に"""
        }]
    )
    return response.choices[0].message.content

def save_as_wav(wav_bytes: bytes, filename: str):
    """WAVファイルとして保存する"""
    with open(filename, 'wb') as f:
        f.write(wav_bytes)
    print(f"音声ファイルを保存しました: {filename}")

pip install simpleaudio

import simpleaudio as sa

def play_audio_simpleaudio(wav_bytes: bytes):
    """simpleaudioで音声ファイルを再生する"""
    wave_obj = sa.WaveObject.from_wave_read(wave.open(io.BytesIO(wav_bytes)))
    play_obj = wave_obj.play()
    play_obj.wait_done()  # 再生完了まで待つ

def split_text(text: str, max_length: int = 200) -> list[str]:
    """テキストを読点・句点で分割する"""
    import re
    # 句点・読点で分割
    sentences = re.split(r'[。！？\n]', text)
    chunks = []
    current_chunk = ""

    for sentence in sentences:
        if not sentence.strip():
            continue
        if len(current_chunk) + len(sentence) <= max_length:
            current_chunk += sentence + "。"
        else:
            if current_chunk:
                chunks.append(current_chunk)
            current_chunk = sentence + "。"

    if current_chunk:
        chunks.append(current_chunk)
    return chunks

def speak_long_text(text: str, speaker: int = SPEAKER_ID):
    """長いテキストを分割して読み上げる"""
    chunks = split_text(text)
    for chunk in chunks:
        wav = text_to_speech_voicevox_safe(chunk, speaker)
        if wav:
            play_audio(wav)