pip install fish-speech

git clone https://github.com/fishaudio/fish-speech
cd fish-speech
pip install -e .

docker pull fishaudio/fish-speech:latest
docker run --gpus all -p 8080:8080 fishaudio/fish-speech:latest

from fish_speech import FishSpeech
 
# Initialize
model = FishSpeech()
 
# Generate speech
audio = model.synthesize("Hello, this is Fish Speech!")
 
# Save to file
audio.save("output.wav")

from fish_speech import FishSpeech
 
model = FishSpeech()
 
# Stream audio chunks as they're generated
for chunk in model.synthesize_stream("This is a longer text that will be streamed in real-time."):
    play_audio(chunk)

# English
audio_en = model.synthesize("Hello world", language="en")
 
# Chinese
audio_zh = model.synthesize("你好世界", language="zh")
 
# Japanese
audio_ja = model.synthesize("こんにちは世界", language="ja")
 
# Spanish
audio_es = model.synthesize("Hola mundo", language="es")
 
# German
audio_de = model.synthesize("Hallo Welt", language="de")

# Automatic language detection
audio = model.synthesize("Bonjour le monde", language="auto")

# Clone from reference
voice = model.clone_voice(
    reference_audio="speaker.wav",
    reference_text="This is the reference text."  # Optional but improves quality
)
 
# Use cloned voice
audio = model.synthesize(
    "Now speaking in the cloned voice!",
    voice=voice
)

voice = model.clone_voice_zero_shot("speaker.wav")
audio = model.synthesize("Speaking in cloned voice.", voice=voice)

audio = model.synthesize(
    "This is an exciting announcement!",
    speed=1.2,           # 0.5 - 2.0
    pitch=1.1,           # 0.5 - 2.0
    energy=1.15          # 0.5 - 2.0
)

ssml_text = """
<speak>
    <prosody rate="slow">Welcome to Fish Speech.</prosody>
    <break time="500ms"/>
    <prosody pitch="high">It's fast and efficient!</prosody>
</speak>
"""
 
audio = model.synthesize_ssml(ssml_text)

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from fish_speech import FishSpeech
 
app = FastAPI()
model = FishSpeech()
 
@app.post("/synthesize")
async def synthesize(text: str, language: str = "en"):
    audio = model.synthesize(text, language=language)
    return StreamingResponse(
        audio.to_wav_stream(),
        media_type="audio/wav"
    )
 
@app.post("/synthesize/stream")
async def synthesize_stream(text: str):
    async def generate():
        for chunk in model.synthesize_stream(text):
            yield chunk.to_bytes()
 
    return StreamingResponse(generate(), media_type="audio/wav")

fish-speech serve --host 0.0.0.0 --port 8080

version: '3.8'
services:
  fish-speech:
    image: fishaudio/fish-speech:latest
    runtime: nvidia
    ports:
      - "8080:8080"
    environment:
      - CUDA_VISIBLE_DEVICES=0
    volumes:
      - ./voices:/app/voices  # Custom voices
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

services:
  fish-speech:
    image: fishaudio/fish-speech:cpu
    ports:
      - "8080:8080"
    environment:
      - OMP_NUM_THREADS=4

texts = [
    "First sentence.",
    "Second sentence.",
    "Third sentence."
]
 
# Batch synthesis for better throughput
audios = model.synthesize_batch(texts)

# Enable voice embedding cache
model = FishSpeech(cache_embeddings=True)
 
# First call computes embedding
audio1 = model.synthesize("Text 1", voice=custom_voice)
 
# Subsequent calls use cached embedding
audio2 = model.synthesize("Text 2", voice=custom_voice)  # Faster

# INT8 quantization for reduced memory
model = FishSpeech(quantization="int8")

# Install optimized build
pip install fish-speech[edge]
 
# Run with CPU optimizations
fish-speech serve --device cpu --threads 4

# Export to ONNX for mobile deployment
model.export_onnx("fish_speech.onnx")

def notify(message: str):
    audio = model.synthesize(message, speed=1.1)
    play_audio(audio)
 
notify("You have a new message from John.")

async def caption_stream(text_stream):
    async for text in text_stream:
        async for audio_chunk in model.synthesize_stream_async(text):
            yield audio_chunk

def generate_audiobook(chapters: list[str], output_dir: str):
    for i, chapter in enumerate(chapters):
        audio = model.synthesize(chapter)
        audio.save(f"{output_dir}/chapter_{i:03d}.wav")