🌐 LiveTranslator - Real-Time Multilingual Speech Translation System

🚀 Overview

LiveTranslator is a cutting-edge real-time speech translation system that seamlessly converts spoken language into text, translates it to target languages, and synthesizes it back into speech. Built with modern web technologies, this system provides instant multilingual communication capabilities through an intuitive web interface.

✨ Key Features

• 🎙️ Real-time Speech Recognition (STT): Convert audio input to text with high accuracy
• 🌍 Multi-language Translation: Support for multiple language pairs with advanced translation models
• 🔊 Text-to-Speech Synthesis (TTS): Natural-sounding voice output in target languages
• ⚡ WebSocket Communication: Ultra-low latency real-time data streaming
• 📱 Responsive Web Interface: Modern, intuitive UI for seamless user experience
• 🔧 Modular Architecture: Easy integration with various STT, translation, and TTS services
• 📊 RESTful API: Comprehensive API endpoints for integration with external systems
• 🐳 Docker Support: Containerized deployment for easy scaling and management

🏗️ Architecture

The system is built with a microservices architecture, featuring:

• Backend: FastAPI-based REST API with WebSocket support
• Frontend: Modern web interface with real-time communication
• Services: Modular design supporting multiple AI/ML providers
• Database: Flexible data storage for translation history (optional)

📁 Project Structure

LiveTranslator/
├── backend/                          # FastAPI Backend Application
│   ├── api/                         # API Routes & WebSocket Handlers
│   │   ├── rest_routes.py           # REST API endpoints
│   │   ├── ws_routes.py             # WebSocket communication
│   │   ├── feedback_routes.py       # User feedback endpoints
│   │   ├── file_routes.py           # File upload/download handlers
│   │   └── image_routers.py         # Image processing routes
│   ├── services/                    # Core Business Logic
│   │   ├── stt_service.py           # Speech-to-Text processing
│   │   ├── translation_service.py   # Language translation engine
│   │   ├── tts_service.py           # Text-to-Speech synthesis
│   │   ├── websocket_service.py     # Real-time communication
│   │   ├── image_translation_service.py  # Image text translation
│   │   ├── file_translate_service.py     # Document translation
│   │   ├── draw_service.py          # Drawing/annotation services
│   │   └── punctuation.py           # Text punctuation enhancement
│   ├── models/                      # Data Models & Schemas
│   │   ├── stt_model.py             # STT request/response models
│   │   ├── translation_model.py     # Translation data models
│   │   ├── tts_model.py             # TTS configuration models
│   │   └── feedback_model.py        # User feedback models
│   ├── utils/                       # Utility Functions
│   │   ├── audio_utils.py           # Audio processing utilities
│   │   ├── error_handler.py         # Error handling middleware
│   │   └── logger.py                # Logging configuration
│   ├── test/                        # Test Suite
│   │   ├── test_stt_service.py      # STT service tests
│   │   ├── test_translation_service.py  # Translation tests
│   │   ├── test_tts_service.py      # TTS service tests
│   │   └── test_websocket_service.py     # WebSocket tests
│   ├── main.py                      # FastAPI application entry point
│   ├── database.py                  # Database configuration
│   ├── init_db.py                   # Database initialization
│   └── requirements.txt             # Python dependencies
├── frontend/                        # Web Frontend
│   ├── templates/                   # HTML Templates
│   │   ├── index.html               # Main application page
│   │   ├── live_translator.html     # Real-time translation interface
│   │   ├── file_translator.html     # File translation interface
│   │   ├── live_camera.html         # Camera-based translation
│   │   ├── about.html               # About page
│   │   └── contact.html             # Contact page
│   ├── static/                      # Static Assets
│   │   ├── css/
│   │   │   └── style.css            # Main stylesheet
│   │   ├── js/
│   │   │   └── ws-client.js         # WebSocket client
│   │   └── img/                     # Image assets
│   ├── package.json                 # Frontend dependencies
│   └── README.md                    # Frontend documentation
├── docs/                            # Documentation
│   ├── api.md                       # API documentation
│   ├── setup.md                     # Setup guide
│   └── deploy.md                    # Deployment guide
├── scripts/                         # Development Scripts
│   ├── setup.sh                     # Environment setup
│   └── dev.sh                       # Development server
├── data/                            # Data storage
├── logs/                            # Application logs
├── Dockerfile                       # Docker configuration
├── docker-compose.yml               # Docker Compose setup
├── render.yaml                      # Render deployment config
└── README.md                        # This file

🛠️ Technology Stack

Backend

• Framework: FastAPI (Python 3.9+)
• WebSocket: websockets library
• Audio Processing: librosa, soundfile
• AI/ML Services:
  • Speech Recognition: Whisper, Google Cloud Speech
  • Translation: MarianMT, OpenAI, Google Translate
  • Text-to-Speech: gTTS, OpenAI TTS
• Data Validation: Pydantic
• Testing: pytest

Frontend

• Core: HTML5, CSS3, JavaScript (ES6+)
• Real-time Communication: WebSocket API
• Audio Processing: Web Audio API
• UI Framework: Custom responsive design
• Build Tools: Modern web standards

DevOps

• Containerization: Docker & Docker Compose
• Deployment: Render, Heroku, AWS compatible
• Monitoring: Built-in logging and error tracking

🚀 Quick Start

Prerequisites

• Python 3.9 or higher
• Node.js 16+ (for frontend development)
• Git

1. Clone the Repository

git clone https://github.com/yourusername/LiveTranslator.git
cd LiveTranslator

2. Set Up Python Environment

# Create virtual environment
python -m venv venv

# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

# Install dependencies
pip install -r backend/requirements.txt

3. Configure Environment

# Copy environment template
cp .env.example .env

# Edit .env file with your configuration
# Add API keys for your chosen services

4. Start the Application

# Start backend server
uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000

# Access the application
# Backend API: http://localhost:8000
# Frontend: http://localhost:8000
# API Documentation: http://localhost:8000/docs

5. Docker Deployment (Alternative)

# Build and run with Docker Compose
docker-compose up --build

# Access the application
# http://localhost:8000

📚 API Documentation

REST API Endpoints

WebSocket Endpoints

Example Usage

import requests

# Speech-to-Text
with open('audio.wav', 'rb') as f:
    response = requests.post('http://localhost:8000/stt', files={'audio': f})
    text = response.json()['text']

# Translation
response = requests.post('http://localhost:8000/translate', json={
    'text': 'Hello world',
    'source_lang': 'en',
    'target_lang': 'vi'
})
translated = response.json()['translated_text']

🔧 Configuration

Environment Variables

# API Keys
OPENAI_API_KEY=your_openai_key
GOOGLE_CLOUD_CREDENTIALS=path_to_credentials.json

# Service Configuration
STT_SERVICE=whisper  # whisper, google, openai
TRANSLATION_SERVICE=marianmt  # marianmt, openai, google
TTS_SERVICE=gtts  # gtts, openai

# Database
DATABASE_URL=sqlite:///./translator.db

# Logging
LOG_LEVEL=INFO

Supported Services

Speech-to-Text

• Whisper: OpenAI's open-source speech recognition
• Google Cloud Speech: Enterprise-grade STT
• OpenAI Whisper API: Cloud-based Whisper

Translation

• MarianMT: Open-source neural machine translation
• OpenAI GPT: Advanced language model translation
• Google Translate: Comprehensive translation service

Text-to-Speech

• gTTS: Google Text-to-Speech
• OpenAI TTS: High-quality voice synthesis
• Azure Speech: Microsoft's TTS service

🧪 Testing

# Run all tests
pytest backend/test/

# Run specific test file
pytest backend/test/test_stt_service.py

# Run with coverage
pytest --cov=backend backend/test/

📦 Deployment

Production Deployment

1. Environment Setup

   # Set production environment variables
   export ENVIRONMENT=production
   export LOG_LEVEL=WARNING
   

2. Docker Deployment

   docker-compose -f docker-compose.prod.yml up -d
   

3. Manual Deployment

   # Install production dependencies
   pip install -r backend/requirements.txt --no-dev
   
   # Start with production server
   gunicorn backend.main:app -w 4 -k uvicorn.workers.UvicornWorker
   

Cloud Platforms

• Render: Use render.yaml for automatic deployment
• Heroku: Compatible with Heroku's Python buildpack
• AWS: Deploy using ECS or EC2
• Google Cloud: Use Cloud Run or Compute Engine

🤝 Contributing

We welcome contributions from the community! Please follow these guidelines:

Development Workflow

1. Fork the repository
2. Create a feature branch

   git checkout -b feature/amazing-feature
   

3. Make your changes
4. Add tests for new functionality
5. Commit with clear messages

   git commit -m "feat: add new translation service"
   

6. Push to your branch

   git push origin feature/amazing-feature
   

7. Create a Pull Request

Code Standards

• Follow PEP 8 for Python code
• Use type hints for function parameters
• Write comprehensive docstrings
• Maintain test coverage above 80%
• Follow conventional commit messages

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• OpenAI for Whisper and GPT models
• Hugging Face for MarianMT and transformers
• Google for gTTS and Cloud Speech services
• FastAPI community for the excellent framework
• All contributors and users of this project

📞 Support

• Documentation: docs/
• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Email: support@livetranslator.com

---