ElevenLabs API Compatibility

docker run -d \
  --name elevenlabs-proxy \
  -p 8080:8080 \
  -e TTS_SERVER_WS=ws://your-tts-server:8000/ws/tts \
  -e SUPABASE_URL=https://your-project.supabase.co \
  -e SUPABASE_SERVICE_KEY=your-service-key \
  kugelaudio/elevenlabs-proxy:latest

version: '3.8'
services:
  elevenlabs-proxy:
    image: kugelaudio/elevenlabs-proxy:latest
    ports:
      - "8080:8080"
    environment:
      - TTS_SERVER_WS=ws://tts-server:8000/ws/tts
      - SUPABASE_URL=${SUPABASE_URL}
      - SUPABASE_SERVICE_KEY=${SUPABASE_SERVICE_KEY}

# Install dependencies
cd backend
uv sync

# Set environment variables
export TTS_SERVER_WS=ws://localhost:8000/ws/tts
export SUPABASE_URL=https://your-project.supabase.co
export SUPABASE_SERVICE_KEY=your-service-key

# Run the proxy
uv run uvicorn src.elevenlabs_proxy.proxy:app --host 0.0.0.0 --port 8080

from elevenlabs import ElevenLabs

# Point to the proxy instead of ElevenLabs
client = ElevenLabs(
    api_key="your-kugelaudio-api-key",
    base_url="http://localhost:8080"
)

# Use exactly like ElevenLabs!
audio = client.text_to_speech.convert(
    voice_id="your-voice-id",
    text="Hello from KugelAudio!",
    model_id="kugel-1-turbo",
)

# Save or play the audio
with open("output.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)

from elevenlabs import ElevenLabs

client = ElevenLabs(
    api_key="your-api-key",
    base_url="http://localhost:8080"
)

# Stream audio chunks
audio_stream = client.text_to_speech.stream(
    voice_id="your-voice-id",
    text="This is streaming audio from KugelAudio.",
    model_id="kugel-1-turbo",
)

for chunk in audio_stream:
    # Play or process each chunk
    play_audio(chunk)

import json
import base64
from websockets.sync.client import connect

# Connect to WebSocket endpoint
ws_url = "ws://localhost:8080/v1/text-to-speech/your-voice-id/stream-input"
ws_url += "?model_id=kugel-1-turbo&output_format=pcm_24000"

with connect(ws_url, additional_headers={"xi-api-key": "your-key"}) as socket:
    # 1. Send initial config
    socket.send(json.dumps({
        "text": " ",
        "try_trigger_generation": True,
        "voice_settings": {
            "stability": 0.5,
            "similarity_boost": 0.75
        }
    }))
    
    # 2. Stream text chunks (e.g., from LLM)
    for chunk in llm_stream():
        socket.send(json.dumps({
            "text": chunk,
            "try_trigger_generation": True
        }))
    
    # 3. Signal end of input
    socket.send(json.dumps({"text": ""}))
    
    # 4. Receive audio chunks
    while True:
        data = json.loads(socket.recv())
        if data.get("audio"):
            audio_bytes = base64.b64decode(data["audio"])
            play_audio(audio_bytes)
        if data.get("isFinal"):
            break

docker compose -f docker/elevenlabs-proxy/docker-compose.yml up -d

# Before (ElevenLabs)
client = ElevenLabs(
    api_key="your-elevenlabs-key",
)

# After (KugelAudio via proxy)
client = ElevenLabs(
    api_key="your-kugelaudio-key",
    base_url="http://localhost:8080"
)

voices = client.voices.get_all()
for voice in voices.voices:
    print(f"{voice.voice_id}: {voice.name}")

curl http://localhost:8080/tts-health

curl http://localhost:8080/v1/voices

audio = client.text_to_speech.convert(
    voice_id="your-voice-id",
    text="Test audio quality",
    model_id="kugel-1-turbo",
    output_format="pcm_24000",  # Try different formats
)