ChatTTS: 39.3K+ Stars — Coqui, MeloTTS와의 대화형 TTS 벤치마크 비교 2026

import ChatTTS
import torch

chat = ChatTTS.Chat()
chat.load(compile=False)

# 화자 임베딩 샘플링 및 저장
rand_spk = chat.sample_random_speaker()
print(f"화자 임베딩 형태: {rand_spk.shape}")

# 나중에 재사용하기 위해 저장
torch.save(rand_spk, "speaker_embedding.pt")

# 가상 환경 생성
conda create -n chattts python=3.11
conda activate chattts

# ChatTTS 설치
pip install ChatTTS

# GPU 가속 선택적 의존성 설치
pip install torchaudio

git clone https://github.com/2noise/ChatTTS
cd ChatTTS
pip install -e .

# 저장소 클론
git clone https://github.com/2noise/ChatTTS
cd ChatTTS

# Docker로 빌드 및 실행
docker build -t chattts .
docker run --gpus all -p 8080:8080 chattts

import ChatTTS
print(f"ChatTTS 버전: {ChatTTS.__version__}")

# 빠른 추론 테스트
chat = ChatTTS.Chat()
chat.load(compile=False)
texts = ["안녕하세요, ChatTTS 테스트입니다."]
wavs = chat.infer(texts)
print(f"생성된 오디오 형태: {wavs[0].shape}")

python examples/web/webui.py

python examples/cmd/run.py "첫 번째 텍스트입니다." "두 번째 텍스트입니다."

# openai_api_server.py — OpenAI 호환 ChatTTS 엔드포인트
import ChatTTS
import torch
import torchaudio
from fastapi import FastAPI
from pydantic import BaseModel
import io
import base64

app = FastAPI()
chat = ChatTTS.Chat()
chat.load(compile=True)  # 프로덕션에서 torch.compile 활성화

class TTSRequest(BaseModel):
    model: str = "chattts"
    input: str
    voice: str = "default"
    response_format: str = "mp3"

@app.post("/v1/audio/speech")
async def create_speech(request: TTSRequest):
    params_infer_code = ChatTTS.Chat.InferCodeParams(
        temperature=0.3,
        top_P=0.7,
        top_K=20,
    )
    wavs = chat.infer([request.input], params_infer_code=params_infer_code)
    buffer = io.BytesIO()
    torchaudio.save(buffer, torch.from_numpy(wavs[0]).unsqueeze(0), 24000, format="mp3")
    buffer.seek(0)
    return {"audio": base64.b64encode(buffer.read()).decode()}

uvicorn openai_api_server:app --host 0.0.0.0 --port 8000 --workers 2

# ChatTTS를 LangChain 에이전트 파이프라인에 통합
from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
import ChatTTS
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

def tts_tool(text: str) -> str:
    """음성을 생성하고 파일 경로를 반환합니다."""
    wavs = chat.infer([text])
    filepath = "/tmp/response.wav"
    torchaudio.save(filepath, torch.from_numpy(wavs[0]).unsqueeze(0), 24000)
    return filepath

tools = [
    Tool(
        name="text_to_speech",
        func=tts_tool,
        description="텍스트 응답을 음성 오디오로 변환"
    )
]

llm = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(llm, tools, prompt="당신은 음성 어시스턴트입니다.")

# 프로덕션 배포용 커스텀 Gradio UI
import gradio as gr
import ChatTTS
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

def generate_speech(text, temperature, top_p, top_k, oral_level, laugh_level, break_level):
    params_refine_text = ChatTTS.Chat.RefineTextParams(
        prompt=f"[oral_{oral_level}][laugh_{laugh_level}][break_{break_level}]"
    )
    params_infer_code = ChatTTS.Chat.InferCodeParams(
        temperature=temperature,
        top_P=top_p,
        top_K=top_k,
    )
    wavs = chat.infer([text], params_refine_text=params_refine_text, params_infer_code=params_infer_code)
    filepath = "/tmp/output.wav"
    torchaudio.save(filepath, torch.from_numpy(wavs[0]).unsqueeze(0), 24000)
    return filepath

demo = gr.Interface(
    fn=generate_speech,
    inputs=[
        gr.Textbox(label="텍스트", value="안녕하세요! 오늘 어떻게 지내세요?"),
        gr.Slider(0.1, 1.0, 0.3, label="Temperature"),
        gr.Slider(0.1, 1.0, 0.7, label="Top P"),
        gr.Slider(1, 50, 20, label="Top K"),
        gr.Slider(0, 9, 2, label="구두 수준"),
        gr.Slider(0, 2, 0, label="웃음 수준"),
        gr.Slider(0, 7, 6, label="멈춤 수준"),
    ],
    outputs=gr.Audio(label="생성된 음성"),
    title="ChatTTS 프로덕션 UI"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

# 실시간 대화용 스트리밍 오디오 생성
import ChatTTS
import numpy as np
import sounddevice as sd

chat = ChatTTS.Chat()
chat.load(compile=True)

class StreamingTTS:
    def __init__(self, chat_model):
        self.chat = chat_model
        self.sample_rate = 24000

    def stream_and_play(self, text: str):
        """오디오를 생성하고 스피커에 청크 단위로 출력합니다."""
        wavs = self.chat.infer([text])
        audio = wavs[0]
        sd.play(audio, self.sample_rate)
        sd.wait()

streamer = StreamingTTS(chat)
streamer.stream_and_play("잠깐 생각해 볼게요...")

# ChatTTS API에 Prometheus 메트릭 추가
from prometheus_client import Counter, Histogram, generate_latest
from fastapi import Response

TTS_REQUESTS = Counter("chattts_requests_total", "총 TTS 요청 수", ["status"])
TTS_LATENCY = Histogram("chattts_inference_seconds", "추론 지연 시간")

@app.post("/v1/audio/speech")
async def create_speech(request: TTSRequest):
    with TTS_LATENCY.time():
        try:
            wavs = chat.infer([request.input])
            TTS_REQUESTS.labels(status="success").inc()
        except Exception as e:
            TTS_REQUESTS.labels(status="error").inc()
            raise

@app.get("/metrics")
async def metrics():
    return Response(generate_latest(), media_type="text/plain")

import ChatTTS
import torchaudio
import time

chat = ChatTTS.Chat()
chat.load(compile=True)

class VoiceAssistant:
    def synthesize_response(self, text: str) -> str:
        start = time.time()
        params = ChatTTS.Chat.InferCodeParams(temperature=0.3, top_P=0.7)
        wavs = chat.infer([text], params_infer_code=params)
        filepath = "/tmp/response.wav"
        torchaudio.save(filepath, torch.from_numpy(wavs[0]).unsqueeze(0), 24000)
        elapsed = time.time() - start
        print(f"TTS 지연 시간: {elapsed:.2f}초")
        return filepath

assistant = VoiceAssistant()
audio_path = assistant.synthesize_response(
    "흥미로운 질문이에요! 생각해 볼게요... [uv_break] "
    "네, 설정에 따라 달라집니다."
)

import ChatTTS
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

# 두 개의 다른 화자 샘플링
speaker_a = chat.sample_random_speaker()  # 여성 음성
speaker_b = chat.sample_random_speaker()  # 남성 음성

dialogue = [
    ("어제 경기 봤어?", speaker_a),
    ("응! 마지막 골이 대박이었어!", speaker_b),
    ("그치? [laugh] 믿을 수가 없었어.", speaker_a),
]

for i, (text, spk) in enumerate(dialogue):
    params = ChatTTS.Chat.InferCodeParams(spk_emb=spk, temperature=0.3)
    wavs = chat.infer([text], params_infer_code=params)
    torchaudio.save(f"dialogue_{i}.wav", torch.from_numpy(wavs[0]).unsqueeze(0), 24000)

import ChatTTS
chat = ChatTTS.Chat()
chat.load(compile=True)  # 지원 모델에서 torch.compile 활성화

import ChatTTS
import torch

chat = ChatTTS.Chat()
chat.load(compile=False)

# 화자 임베딩 생성 및 캐싱
speakers = {}
for name in ["agent", "user", "narrator"]:
    spk = chat.sample_random_speaker()
    speakers[name] = spk
    torch.save(spk, f"speakers/{name}.pt")

# 기존 화자 로드
spk_agent = torch.load("speakers/agent.pt")
params = ChatTTS.Chat.InferCodeParams(spk_emb=spk_agent)

import torch
from ChatTTS import Chat

chat = Chat()
chat.load(compile=False)

@torch.inference_mode()
def infer_with_cleanup(texts, params):
    with torch.cuda.amp.autocast():  # 혼합 정밀도
        wavs = chat.infer(texts, params_infer_code=params)
    torch.cuda.empty_cache()  # GPU 메모리 해제
    return wavs

# health_check.py — Kubernetes용 헬스 프로브
from fastapi import FastAPI, HTTPException
import ChatTTS

app = FastAPI()
chat = ChatTTS.Chat()

try:
    chat.load(compile=False)
    MODEL_LOADED = True
except Exception as e:
    MODEL_LOADED = False
    print(f"모델 로드 실패: {e}")

@app.get("/health")
def health():
    if not MODEL_LOADED:
        raise HTTPException(status_code=503, detail="모델이 로드되지 않음")
    return {"status": "healthy", "model": "chattts", "version": "0.2.5"}

@app.get("/ready")
def ready():
    return {"status": "ready"}

# chattts-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: chattts-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: chattts
  template:
    metadata:
      labels:
        app: chattts
    spec:
      containers:
      - name: chattts
        image: chattts:0.2.5
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: "8Gi"
          requests:
            memory: "4Gi"
        ports:
        - containerPort: 8000
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /ready
            port: 8000
          periodSeconds: 10