TTS Open Source na VPS: Kokoro e Orpheus com HTTP API

Kokoro TTS e o modelo mais pratico pra VPS. E open source, licenca MIT, e foi feito justamente pra ser leve e rapido.

Caracteristicas:

• •Modelo de ~80MB (versao base)
• •Roda 100% em CPU — sem precisar de GPU
• •Velocidade acima do realtime (gera audio mais rapido do que toca)
• •Vozes em ingles, portugues e outros idiomas
• •API HTTP simples via FastAPI

VPS minima pra rodar sem problemas:

• •2 vCPUs
• •4GB RAM
• •Ubuntu 22.04

Salva esse arquivo como server.py na sua VPS:

`python

from fastapi import FastAPI

from fastapi.responses import StreamingResponse

from pydantic import BaseModel

import io

from kokoro_onnx import Kokoro

import soundfile as sf

import numpy as np

app = FastAPI()

kokoro = Kokoro('kokoro-v0_19.onnx', 'voices.json')

class TTSRequest(BaseModel):

text: str

voice: str = 'af_bella'

speed: float = 1.0

@app.post('/tts')

async def generate_tts(req: TTSRequest):

samples, sample_rate = kokoro.create(

req.text,

voice=req.voice,

speed=req.speed,

lang='en-us'

)

buf = io.BytesIO()

sf.write(buf, samples, sample_rate, format='WAV')

buf.seek(0)

return StreamingResponse(buf, media_type='audio/wav')

@app.get('/health')

async def health():

return {'status': 'ok'}

`

A API aceita POST em /tts com JSON e devolve o audio WAV direto. Simples assim.

Com a API rodando na VPS, no N8N e so usar o node HTTP Request:

• •Method: POST
• •URL: http://SEU-IP:8000/tts
• •Body Type: JSON
• •Body: { "text": "{{ $json.text }}", "voice": "af_bella", "speed": 1.0 }
• •Response Format: Binary (para receber o audio)

O retorno e o arquivo WAV diretamente. Voce pode usar esse audio no fluxo do N8N, salvar em storage, enviar via WhatsApp, ou o que precisar.

Para PTbr: existem vozes em portugues no Kokoro, ou voce usa o modelo base em ingles e ajusta o texto transliterado.

Se preferir evitar instalar dependencias direto na VPS, tem imagens Docker prontas:

`bash

# Kokoro com API (imagem da comunidade)

docker run -d \

--name kokoro-tts \

-p 8880:8880 \

ghcr.io/remsky/kokoro-fastapi-cpu:v0.2.2

# Testar

curl -X POST http://localhost:8880/v1/audio/speech \

-H 'Content-Type: application/json' \

-d '{"model":"kokoro","input":"Ola mundo!","voice":"af_bella"}' \

--output audio.mp3

`

Essa imagem expoe API compativel com OpenAI (/v1/audio/speech), o que facilita integracao com ferramentas que ja suportam o padrao OpenAI TTS.

Orpheus TTS e baseado em LLM (Llama 3B) e gera vozes com qualidade muito superior, incluindo emocoes e entonacoes naturais. A contrapartida e o hardware necessario.

Requisitos reais:

• •GPU recomendada: 8GB de VRAM (ex: RTX 3070, RTX 4060)
• •CPU-only: possivel, mas lento (10-30x mais devagar que realtime)
• •RAM: minimo 16GB

Setup com Ollama (forma mais simples):

`bash

# Instalar Ollama

curl -fsSL https://ollama.com/install.sh | sh

# Baixar o modelo Orpheus

ollama pull hugging-quants/orpheus-3b-0.1-ft-q4_k_m

# Subir servidor

ollama serve

`

Para servir via HTTP API, voce cria um wrapper FastAPI que chama o Ollama internamente e converte o output em audio.

Com Ollama rodando, cria esse wrapper para expor HTTP limpo:

`python

from fastapi import FastAPI

from fastapi.responses import StreamingResponse

from pydantic import BaseModel

import requests

import io

import soundfile as sf

app = FastAPI()

class TTSRequest(BaseModel):

text: str

voice: str = 'tara'

speed: float = 1.0

ORPHEUS_VOICES = ['tara', 'leah', 'jess', 'leo', 'dan', 'mia', 'zac', 'zoe']

@app.post('/tts')

async def tts(req: TTSRequest):

voice = req.voice if req.voice in ORPHEUS_VOICES else 'tara'

prompt = f'<|audio|>{voice}: {req.text}<|eot_id|>'

resp = requests.post('http://localhost:11434/api/generate', json={

'model': 'hugging-quants/orpheus-3b-0.1-ft-q4_k_m',

'prompt': prompt,

'stream': False

})

# Converter tokens de audio em WAV (simplificado)

audio_tokens = resp.json()['response']

# Processamento de tokens -> audio via snac decoder

# (implementacao completa no repo oficial)

return {'status': 'audio gerado', 'tokens': len(audio_tokens)}

@app.get('/health')

async def health():

return {'status': 'ok', 'model': 'orpheus'}

`

A implementacao completa do decoder SNAC esta nos repos da comunidade no GitHub.

Para Kokoro TTS (sem GPU):

• •Hostinger VPS 4 ($4.99/mes) — 4 vCPUs, 4GB RAM, 50GB SSD
• •DigitalOcean Droplet Basic — $12/mes com 2GB RAM (suficiente)
• •Hetzner CX22 — 3.29 EUR/mes, excelente custo-beneficio

Para Orpheus TTS (com GPU):

• •RunPod.io — GPU spot price, ~$0.20/h pra RTX 3070
• •Vast.ai — ainda mais barato em alguns momentos
• •Lambda Labs — GPU A10 por $0.75/h, estavel

Para automacoes de N8N rodando 24/7, Kokoro numa VPS de $5-10/mes e a combinacao ideal. Fica ativo o tempo todo, sem custo variavel por chamada.