Pular para o conteúdo

Pesquise guias, comandos, ferramentas MCP e arquitetura

Geral

Voz neural (XTTS v2) e transcrição (STT)

Nas duas edições, a Hikari envia notas de voz nativas do aplicativo em vez de anexos .mp3 comuns. No Discord, a mensagem aparece com o player oficial de microfone (flags: 8192), seletor de velocidade (1x, 1.5x, 2x) e waveform de 256 picos; no WhatsApp, é entregue como gravação PTT em OGG Opus (ptt: true).

[Pedido do usuário]
│
▼
[LLM] -> Aciona 'send_voice_note', trigger '!' (Discord) ou '.' / '>audio' / '>falar' (WhatsApp)
│
▼
[cleanForTts] -> Dicionário fonético PT-BR e remoção de links, códigos e emojis
│
├──► 1º Hugging Face Space (ZeroGPU) (~5 a 7 s, Always-ON)
│ │ (Se ocupado ou sem cota)
└──► 2º Modal.com (NVIDIA T4) (~1,5 a 2 s aquecido / ~35 a 45 s cold start)
│
▼
[FFmpeg OGG Opus 48 kbps VBR] -> voice-message.ogg (Discord) / PTT (WhatsApp)
│
├──► Discord: Cálculo de 256 blocos PCM RMS em Base64 + Upload REST em 2 etapas
└──► Bypass: registerBotAudio() salva o texto original em transcriptionCache

Antes da chamada ao servidor de voz, os blocos de código, URLs, menções e emojis são filtrados e palavras recorrentes em inglês são adaptadas para pronúncia natural em português brasileiro (discord → "discórd", gameplay → "gueime-plei", setup → "setáp", wifi → "uai-fai").

Provedor Prioridade Tempo aquecido Partida a frio Cota / Comportamento
Hugging Face Space Primário ~5,5 s ~5 a 7 s Always-ON com alocação ZeroGPU por chamada (@spaces.GPU)
Modal.com Serverless Fallback ~1,5 a 2,0 s ~35 a 45 s GPU T4 sob demanda (créditos mensais gratuitos), timeout de 90s

Como bibliotecas de alto nível costumam ignorar metadados internos da waveform, o envio no Discord executa o fluxo oficial em REST (v10):

  1. O FFmpeg converte o WAV de saída (24.000 Hz) via streaming (-c:a libopus -b:a 48k -vbr on -f ogg) com o nome obrigatório voice-message.ogg.
  2. O sistema analisa as amostras PCM de 16 bits, divide em 256 blocos uniformes e codifica o pico RMS normalizado (0 a 255) em Base64.
  3. Executa upload em duas etapas na API REST: POST /channels/{channel_id}/attachments para obter URL pré-assinada, PUT enviando o binário OGG, e POST /channels/{channel_id}/messages com flags: 8192, duration_secs e waveform.

Gatilhos de voz no Discord:

  • Decisão autônoma (send_voice_note): durante a síntese, o bot exibe status temporário Gravando voz... antes de publicar o áudio. Se houver dados sobre o criador ou tópicos salvos, consulta db_read antes de gerar a fala curta (1 a 4 frases).
  • Gatilho forçado do proprietário (!): quando o dono configurado (config.isOwner) inicia a mensagem com ! (por nome, menção ou resposta a uma mensagem da Hikari), a resposta sai obrigatoriamente falada.
  • Slash /ia_chat: use voice:True para forçar nota de voz ou voice:False para manter em texto. Caso os provedores TTS falhem, o texto vai normalmente com o rodapé Houve uma falha na voz..

Bypass de Whisper (transcriptionCache): assim que a mensagem de voz do bot é enviada, registerBotAudio(messageId, text) guarda o texto original em cache. Quando um membro responde àquele áudio ou o histórico é lido, resolveMessageAudioContent recupera o texto sem gastar API de transcrição (Hikari: [audio transcrito]: texto).

  • No Discord (histórico sob demanda): áudios presentes no histórico do canal só são transcritos quando alguém menciona ou pergunta algo à Hikari naquele canal, usando Wit.ai em prioridade e fallback automático para Groq (whisper-large-v3-turbo). O resultado fica em cache por ID da mensagem; arquivos de música (.mp3) não são transcritos e mantêm apenas o nome do arquivo no histórico.
  • No WhatsApp (>transcrever e DM): o módulo src/services/sttService.js implementa download com cabeçalhos anti-403 para mídias do WhatsApp e tenta na ordem configurada: Groq (whisper-large-v3-turbo, abaixo de 800 ms), Wit.ai, OpenAI Whisper (OPENAI_STT_KEY) e endpoints próprios (HF_STT_URL ou LOCAL_STT_URL).

Tutorial: clonagem e hospedagem própria de XTTS v2

Seção intitulada “Tutorial: clonagem e hospedagem própria de XTTS v2”

Em vez de treinar um modelo inteiro do zero, o XTTS v2 extrai dois vetores latentes (gpt_cond_latent e speaker_embedding) a partir de uma amostra limpa de voz (30s a 2 min sem ruído, eco ou música, em WAV 24.000 ou 44.100 Hz mono).

Com Python 3.10 ou 3.11 e o pacote TTS instalado:

import torch
from TTS.api import TTS
audio_referencia = "golden_sample.wav"
arquivo_saida = "voz_personalizada_v1.pth"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(
"cuda" if torch.cuda.is_available() else "cpu"
)
gpt_cond_latent, speaker_embedding = tts.synthesizer.tts_model.get_conditioning_latents(
audio_path=[audio_referencia]
)
torch.save(
{
"gpt_cond_latent": gpt_cond_latent.cpu(),
"speaker_embedding": speaker_embedding.cpu(),
},
arquivo_saida,
)

Crie um Space em huggingface.co/spaces com SDK Gradio e hardware ZeroGPU, enviando voz_personalizada_v1.pth junto dos arquivos abaixo:

requirements.txt:

torch
torchaudio
soundfile
numpy
TTS
spaces
gradio
gradio_client

app.py:

import os
import spaces
import torch
import numpy as np
import soundfile as sf
import gradio as gr
from TTS.api import TTS
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
MODEL_PATH = os.path.join(BASE_DIR, "voz_personalizada_v1.pth")
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")
latents_data = torch.load(MODEL_PATH, map_location="cpu")
cond_latent = latents_data["gpt_cond_latent"].to("cuda")
speaker_emb = latents_data["speaker_embedding"].to("cuda")
@spaces.GPU(duration=30)
def synthesize(text, model="v1", speed=1.15, temperature=0.65, pause_spacing_ms=200):
if not text or len(text.strip()) == 0:
return None
out = tts.synthesizer.tts_model.inference(
text=text,
language="pt",
gpt_cond_latent=cond_latent,
speaker_embedding=speaker_emb,
temperature=temperature,
speed=speed,
enable_text_splitting=True,
)
out_path = os.path.join(BASE_DIR, "output.wav")
sf.write(out_path, np.array(out["wav"]), 24000, format="WAV")
return out_path
with gr.Blocks(title="Neural Voice TTS") as demo:
t_in = gr.Textbox(label="Texto")
m_in = gr.Dropdown(choices=["v1"], value="v1", label="Modelo")
s_in = gr.Slider(0.8, 1.5, value=1.15, label="Velocidade")
tmp_in = gr.Slider(0.4, 0.9, value=0.65, label="Temperatura")
p_in = gr.Slider(50, 400, value=200, label="Pausa (ms)")
btn = gr.Button("Sintetizar")
a_out = gr.Audio(label="Áudio", type="filepath")
btn.click(
synthesize,
inputs=[t_in, m_in, s_in, tmp_in, p_in],
outputs=[a_out],
api_name="synthesize",
)
demo.launch(server_name="0.0.0.0", server_port=7860)

Copie a URL gerada (https://seu-usuario-space.hf.space) para HF_TTS_ENDPOINT no .env.

Variável Função Valor de referência
HF_TTS_ENDPOINT Space Hugging Face ZeroGPU primário URL .hf.space
MODAL_TTS_ENDPOINT Fallback Serverless NVIDIA T4 no Modal URL .modal.run
VOICE_SPEED Velocidade da síntese vocal (0.5 a 2.0) 1.15
VOICE_TEMPERATURE Variação e entonação da voz (0.0 a 2.0) 0.65
VOICE_MAX_CHARS Teto de caracteres enviados por síntese 180 (Discord) / 1000 (WhatsApp)
VOICE_CHAT_ENABLED Ativa notas de voz no chat do Discord true / false
WIT_AI_KEY / WITAI_TOKEN Chave gratuita para transcrição STT Console Wit.ai
GROQ_API_KEY Chave da Groq para whisper-large-v3-turbo Console Groq