LibreTranslate：1.44万星标的自托管翻译API

# Run with Docker
docker run -ti --rm -p 5000:5000 \
  -v lt-models:/home/libretranslate/.local \
  -e LT_LOAD_ONLY=en,es,fr \
  libretranslate/libretranslate:latest

# docker-compose.yml - Production Setup
version: '3.8'

services:
  libretranslate:
    container_name: libretranslate
    image: libretranslate/libretranslate:v1.9.5
    restart: unless-stopped
    ports:
      - "5000:5000"
    environment:
      - LT_LOAD_ONLY=en,es,fr,de,it,zh,ja,ru,pt,pl,nl
      - LT_API_KEYS=true
      - LT_REQ_LIMIT=60
      - LT_THREADS=4
      - LT_UPDATE_MODELS=true
    volumes:
      - lt-models:/home/libretranslate/.local
      - lt-db:/app/db
    healthcheck:
      test: ['CMD-SHELL', './venv/bin/python scripts/healthcheck.py']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    deploy:
      resources:
        limits:
          memory: 4G
        reservations:
          memory: 2G

volumes:
  lt-models:
  lt-db:

docker compose up -d

# Clone the repository
git clone https://github.com/LibreTranslate/LibreTranslate.git
cd LibreTranslate

# Build and run CUDA-enabled version
docker compose -f docker-compose.cuda.yml up -d --build

nvidia-smi

# Install via pip
pip install libretranslate==1.9.5

# Start the server
libretranslate --host 0.0.0.0 --port 5000 \
  --load-only en,es,fr,de \
  --req-limit 60 \
  --threads 4

git clone https://github.com/LibreTranslate/LibreTranslate.git
cd LibreTranslate
pip install -e .
python main.py --host 0.0.0.0 --port 5000

# On a fresh Ubuntu 24.04 Droplet
curl -fsSL https://get.docker.com | sh
mkdir -p ~/libretranslate && cd ~/libretranslate

# Create production compose file
cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  libretranslate:
    image: libretranslate/libretranslate:v1.9.5
    restart: always
    ports:
      - "5000:5000"
    environment:
      - LT_LOAD_ONLY=en,es,fr,de,it,zh,ja,ru,pt
      - LT_API_KEYS=true
      - LT_REQ_LIMIT=120
      - LT_THREADS=4
    volumes:
      - ./models:/home/libretranslate/.local
      - ./db:/app/db
EOF

docker compose up -d

# translate_client.py
import requests

LIBRETRANSLATE_URL = "http://localhost:5000/translate"

def translate_text(text: str, source: str = "en", target: str = "es") -> str:
    payload = {
        "q": text,
        "source": source,
        "target": target,
        "format": "text",
        "api_key": ""  # Add your API key if enabled
    }
    headers = {"Content-Type": "application/json"}

    response = requests.post(LIBRETRANSLATE_URL, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()["translatedText"]

# Example usage
if __name__ == "__main__":
    result = translate_text("Hello, production deployment!", "en", "de")
    print(f"Translated: {result}")

// libretranslate-client.ts
interface TranslateResponse {
  translatedText: string;
}

class LibreTranslateClient {
  private baseUrl: string;
  private apiKey?: string;

  constructor(baseUrl: string = "http://localhost:5000", apiKey?: string) {
    this.baseUrl = baseUrl;
    this.apiKey = apiKey;
  }

  async translate(
    text: string,
    source: string = "en",
    target: string = "es"
  ): Promise<string> {
    const response = await fetch(`${this.baseUrl}/translate`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        q: text,
        source,
        target,
        format: "text",
        api_key: this.apiKey,
      }),
    });

    if (!response.ok) {
      throw new Error(`Translation failed: ${response.statusText}`);
    }

    const data: TranslateResponse = await response.json();
    return data.translatedText;
  }
}

// Usage
const client = new LibreTranslateClient("http://localhost:5000");
const result = await client.translate("Deploy to production", "en", "fr");
console.log(result); // "Déployer en production"

# whisper_translate_pipeline.py
import whisper
import requests

WHISPER_MODEL = whisper.load_model("base")
LIBRE_URL = "http://localhost:5000/translate"

def transcribe_and_translate(audio_path: str, target_lang: str = "en") -> dict:
    # Step 1: Transcribe audio with Whisper
    result = WHISPER_MODEL.transcribe(audio_path)
    source_text = result["text"]
    detected_lang = result.get("language", "auto")

    # Step 2: Translate with LibreTranslate
    payload = {
        "q": source_text,
        "source": detected_lang,
        "target": target_lang,
        "format": "text"
    }
    response = requests.post(LIBRE_URL, json=payload)
    translated = response.json()["translatedText"]

    return {
        "original": source_text,
        "translated": translated,
        "source_language": detected_lang,
        "target_language": target_lang
    }

# Run pipeline
output = transcribe_and_translate("meeting.mp3", target_lang="es")
print(f"ES: {output['translated']}")

# translate_and_speak.py
import requests
from TTS.api import TTS

# Initialize TTS
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)

def translate_and_speak(text: str, target_lang: str, speaker_wav: str):
    # Translate
    payload = {"q": text, "source": "en", "target": target_lang, "format": "text"}
    response = requests.post("http://localhost:5000/translate", json=payload)
    translated = response.json()["translatedText"]

    # Synthesize speech
    output_path = f"output_{target_lang}.wav"
    tts.tts_to_file(
        text=translated,
        speaker_wav=speaker_wav,
        language=target_lang,
        file_path=output_path
    )
    return output_path

# Generate multilingual audio
for lang in ["es", "fr", "de"]:
    translate_and_speak("Welcome to our service", lang, "reference.wav")

# Basic translation
curl -X POST http://localhost:5000/translate \
  -H "Content-Type: application/json" \
  -d '{"q": "Hello world", "source": "en", "target": "es"}'

# Response: {"translatedText": "Hola mundo"}

# Detect language
curl -X POST http://localhost:5000/detect \
  -H "Content-Type: application/json" \
  -d '{"q": "Bonjour le monde"}'

# Get supported languages
curl http://localhost:5000/languages

# Translate with API key (if enabled)
curl -X POST http://localhost:5000/translate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{"q": "Production deployment", "source": "en", "target": "de"}'

# HTML translation
curl -X POST http://localhost:5000/translate \
  -H "Content-Type: application/json" \
  -d '{
    "q": "<p>Hello <b>world</b></p>",
    "source": "en",
    "target": "fr",
    "format": "html"
  }'

# /etc/nginx/sites-available/libretranslate
server {
    listen 443 ssl http2;
    server_name translate.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    client_max_body_size 50M;

    location / {
        proxy_pass http://localhost:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
    }
}

# Redirect HTTP to HTTPS
server {
    listen 80;
    server_name translate.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

sudo ln -s /etc/nginx/sites-available/libretranslate /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

# docker-compose.yml with API keys
services:
  libretranslate:
    image: libretranslate/libretranslate:v1.9.5
    environment:
      - LT_API_KEYS=true
      - LT_REQ_LIMIT=100
      - LT_REQ_LIMIT_PER_DAY=10000
    volumes:
      - lt-models:/home/libretranslate/.local
      - lt-db:/app/db

# Load only European languages
LT_LOAD_ONLY=en,es,fr,de,it,pt,nl,pl,ru docker compose up -d

# Load Asian + European languages
LT_LOAD_ONLY=en,ja,zh,ko,es,fr,de docker compose up -d

# Check service health
curl http://localhost:5000/health

# Expected response: {"status": "ok"}

# prometheus_exporter.py
from prometheus_client import start_http_server, Counter, Histogram
import requests
import time

TRANSLATION_COUNTER = Counter('libretranslate_requests_total', 'Total translations')
LATENCY_HISTOGRAM = Histogram('libretranslate_latency_seconds', 'Translation latency')

def monitor():
    start_http_server(9090)
    while True:
        start = time.time()
        requests.post("http://localhost:5000/translate",
            json={"q": "test", "source": "en", "target": "es"})
        LATENCY_HISTOGRAM.observe(time.time() - start)
        TRANSLATION_COUNTER.inc()
        time.sleep(30)

if __name__ == "__main__":
    monitor()

# libretranslate-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: libretranslate
spec:
  replicas: 2
  selector:
    matchLabels:
      app: libretranslate
  template:
    metadata:
      labels:
        app: libretranslate
    spec:
      containers:
      - name: libretranslate
        image: libretranslate/libretranslate:v1.9.5
        ports:
        - containerPort: 5000
        env:
        - name: LT_LOAD_ONLY
          value: "en,es,fr,de,it"
        - name: LT_THREADS
          value: "4"
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        livenessProbe:
          httpGet:
            path: /health
            port: 5000
          initialDelaySeconds: 60
          periodSeconds: 30
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: libretranslate-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: libretranslate
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

kubectl apply -f libretranslate-deployment.yaml

#!/bin/bash
# backup.sh - Daily backup cron job
BACKUP_DIR="/backups/libretranslate"
DATE=$(date +%Y%m%d)

# Backup database
docker cp libretranslate:/app/db "$BACKUP_DIR/db_$DATE.sqlite"

# Sync models (optional - can be re-downloaded)
rsync -av /var/lib/docker/volumes/lt-models/_data/ "$BACKUP_DIR/models/"

# Keep only 7 days of backups
find "$BACKUP_DIR" -name "db_*.sqlite" -mtime +7 -delete

0 2 * * * /path/to/backup.sh

// useTranslation.ts
import { useState, useCallback } from "react";

export function useTranslation() {
  const [translating, setTranslating] = useState(false);

  const translate = useCallback(async (text: string, source: string, target: string) => {
    setTranslating(true);
    try {
      const res = await fetch("http://localhost:5000/translate", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ q: text, source, target }),
      });
      const data = await res.json();
      return data.translatedText;
    } finally {
      setTranslating(false);
    }
  }, []);

  return { translate, translating };
}