Add embeddings API, caching, and Docker revamp

Implement embeddings endpoint (router, service, schemas) using
sentence-transformers and configurable embedding model. Add a TTL cache
and concurrent alternative-language fallback to the subtitles service.
Introduce rate limiting (slowapi), timing-safe API key verification and
updated API key middleware. Replace Dockerfile with a multi-stage
builder/runtime image, set model cache dirs, bump package version to
1.0.0, and update README, tests, .env.example, and .gitignore (ignore
models/)

.env.example

@@ -1,18 +1,32 @@
-# Environment variables template for the multi-utility server
+# Environment variables for the multi-utility server
 # Copy this file to .env and update the values
 
-# API Security - Comma-separated list of valid API keys
-API_KEYS=your-secret-key-1,your-secret-key-2,your-secret-key-3
+# API Security - Comma-separated list of valid API keys (REQUIRED)
+API_KEYS=your-secret-key-1,your-secret-key-2
+
+# CORS Configuration - Comma-separated list of allowed origins (optional, defaults to *)
+CORS_ORIGINS=http://localhost:3000,https://yourdomain.com
+
+# Rate Limiting
+RATE_LIMIT_REQUESTS=100
+RATE_LIMIT_WINDOW=60
 
 # Logging configuration
 LOG_LEVEL=INFO
 
 # yt-dlp configuration
-YT_DLP_BINARY=python -m yt_dlp
 YT_DLP_TIMEOUT_LIST=30
 YT_DLP_TIMEOUT_DOWNLOAD=60
 
+# Embedding model configuration
+EMBEDDING_MODEL=mixedbread-ai/mxbai-embed-large-v1
+# Models cache directory (set by Docker, optional for local dev)
+# SENTENCE_TRANSFORMERS_HOME=models
+
 # Server configuration
 HOST=0.0.0.0
 PORT=8000
-RELOAD=true
+RELOAD=true
+
+# Container-specific (set automatically in Dockerfile)
+# DISABLE_FILE_LOGGING=true

.gitignore

@@ -124,6 +124,7 @@ dmypy.json
 
 # Project specific
 logs/
+models/
 *.log
 .DS_Store
 Thumbs.db

Dockerfile

@@ -1,62 +1,58 @@
-# Use Python 3.11 slim image
-FROM python:3.11-slim
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    POETRY_VERSION=1.7.1 \
-    POETRY_HOME="/opt/poetry" \
-    POETRY_VIRTUALENVS_IN_PROJECT=true \
-    POETRY_NO_INTERACTION=1
-
-# Add Poetry to PATH
-ENV PATH="$POETRY_HOME/bin:$PATH"
-
-# Install system dependencies including curl for health checks
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        curl \
-        build-essential \
-    && rm -rf /var/lib/apt/lists/*
+# Stage 1: Builder - Install dependencies
+FROM python:3.11-slim AS builder
+
+WORKDIR /app
 
 # Install Poetry
-RUN curl -sSL https://install.python-poetry.org | python3 -
+RUN pip install --no-cache-dir poetry==1.8.0
+
+# Configure Poetry for non-interactive installation
+RUN poetry config virtualenvs.create false
+
+# Copy only dependency files first (cache layer)
+COPY pyproject.toml poetry.lock ./
+
+# Install only production dependencies
+RUN poetry install --only main --no-interaction --no-ansi --no-root
+
+# Stage 2: Runtime - Minimal production image
+FROM python:3.11-slim AS runtime
 
-# Set work directory
 WORKDIR /app
 
-# Copy pyproject.toml first
-COPY pyproject.toml ./
+# Copy installed packages from builder
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+
+# Create non-root user for security
+RUN useradd --create-home --shell /bin/bash appuser
 
-# Copy poetry.lock if it exists, otherwise generate it
-COPY poetry.loc[k] ./
-RUN if [ ! -f poetry.lock ]; then \
-        echo "poetry.lock not found, generating it..." && \
-        poetry lock; \
-    fi
+# Create directories with proper ownership
+RUN mkdir -p /app/logs /app/models && chown -R appuser:appuser /app
 
-# Install Python dependencies
-RUN poetry install --only=main --no-dev
+# Copy application code (separate layer for faster rebuilds)
+COPY --chown=appuser:appuser app/ ./app/
 
-# Copy application code
-COPY app/ ./app/
+# Switch to non-root user
+USER appuser
 
-# Create non-root user and set up logging directory
-RUN useradd --create-home --shell /bin/bash app \
-    && mkdir -p /tmp/app-logs \
-    && chown -R app:app /app /tmp/app-logs
+# Environment configuration
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
 
-USER app
+# Hugging Face model cache directory
+ENV HF_HOME=/app/models
+ENV TRANSFORMERS_CACHE=/app/models
+ENV SENTENCE_TRANSFORMERS_HOME=/app/models
 
-# Disable file logging for container environment (stdout only)
+# Disable file logging in container
 ENV DISABLE_FILE_LOGGING=true
 
-# Expose port
-EXPOSE 8000
+EXPOSE 7860
 
-# Health check (temporarily disabled for debugging)
-# HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
-#     CMD curl -f http://localhost:8000/health || exit 1
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/health')" || exit 1
 
-# Run the application
-CMD ["poetry", "run", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,392 +1,147 @@
 # Multi-Utility FastAPI Server
 
-A centralized, extensible FastAPI server that provides reusable APIs for different projects. Instead of spinning up multiple servers, this single server hosts multiple modular APIs with robust authentication, logging, and error handling.
+A centralized, extensible FastAPI server providing reusable APIs with robust authentication, rate limiting, and logging.
 
-## 🚀 Features
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.104+-green.svg)](https://fastapi.tiangolo.com/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-- **Modular Architecture**: Easy to add new APIs and utilities
-- **API Key Authentication**: Secure access with configurable API keys
-- **Comprehensive Logging**: Structured logging with Loguru
-- **Robust Error Handling**: Custom exceptions with proper HTTP status codes
-- **YouTube Subtitle Extractor**: First utility - extract and clean YouTube subtitles
-- **Async Support**: Full async/await support for better performance
-- **Comprehensive Testing**: Unit and integration tests with pytest
-- **Development Tools**: Pre-configured with Black, isort, flake8, and mypy
+## Features
 
-## 📋 Current APIs
+- **Modular Architecture** - Easy to add new APIs
+- **API Key Authentication** - Secure, timing-safe key validation
+- **Rate Limiting** - Configurable per-endpoint limits with `slowapi`
+- **Result Caching** - TTL-based caching with `cachetools`
+- **Structured Logging** - Loguru with console/file output
+- **Docker Ready** - Multi-stage, cache-optimized Dockerfile
 
-### 1. YouTube Subtitle Extractor
+## APIs
 
-Extract and clean subtitles from YouTube videos using yt-dlp.
+| API | Endpoint | Description |
+|-----|----------|-------------|
+| **Subtitles** | `POST /api/v1/subtitles/extract` | Extract YouTube subtitles |
+| **Embeddings** | `POST /api/v1/embeddings/generate` | Generate text embeddings (1024-dim) |
 
-**Endpoint**: `POST /api/v1/subtitles/extract`
+## Quick Start
 
-**Features**:
-- Supports multiple language codes
-- Automatic fallback to alternative language variants
-- Text cleaning and deduplication
-- Timeout protection
-- Direct JSON response (no file storage)
+### Local Development
 
-## 🛠️ Installation
-
-### Prerequisites
-
-- Python 3.11+
-- Poetry (for dependency management)
-
-### Setup
-
-1. **Clone the repository**:
-   ```bash
-   git clone <repository-url>
-   cd multi-utility-server
-   ```
-
-2. **Install dependencies**:
-   ```bash
-   poetry install
-   ```
-
-3. **Configure environment**:
-   ```bash
-   cp .env.example .env
-   # Edit .env file with your API keys and settings
-   ```
-
-4. **Run development server**:
-   ```bash
-   # On Linux/macOS
-   ./scripts/run_dev.sh
-   
-   # On Windows
-   scripts\run_dev.bat
-   
-   # Or manually
-   poetry run uvicorn app.main:app --reload
-   ```
-
-## 🔧 Configuration
-
-### Environment Variables
-
-Create a `.env` file (copy from `.env.example`):
+```bash
+# Install dependencies
+poetry install
 
-```env
-# API Security - Comma-separated list of valid API keys
-API_KEYS=your-secret-key-1,your-secret-key-2,your-secret-key-3
+# Configure environment
+cp .env.example .env
+# Edit .env with your API keys
 
-# Logging configuration
-LOG_LEVEL=INFO
+# Run server
+poetry run uvicorn app.main:app --reload
+```
 
-# yt-dlp configuration
-YT_DLP_BINARY=python -m yt_dlp
-YT_DLP_TIMEOUT_LIST=30
-YT_DLP_TIMEOUT_DOWNLOAD=60
+### Docker
 
-# Server configuration
-HOST=0.0.0.0
-PORT=8000
-RELOAD=true
+```bash
+docker build -t multiutility-server .
+docker run -p 7860:7860 -e API_KEYS=your-key multiutility-server
 ```
 
-### API Key Configuration
-
-The server uses API key authentication. Configure your keys in the `.env` file:
+## Configuration
 
-```env
-API_KEYS=production-key-1,development-key-2,client-key-3
-```
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `API_KEYS` | Comma-separated API keys (required) | - |
+| `CORS_ORIGINS` | Allowed origins | `*` |
+| `RATE_LIMIT_REQUESTS` | Requests per minute | `100` |
+| `LOG_LEVEL` | Logging level | `INFO` |
+| `EMBEDDING_MODEL` | HuggingFace model | `mixedbread-ai/mxbai-embed-large-v1` |
 
-## 📖 API Documentation
+## API Usage
 
 ### Authentication
 
-All API endpoints (except health checks and documentation) require authentication:
+All endpoints (except health checks) require the `x-api-key` header:
 
 ```bash
-# Include API key in request header
-curl -H "x-api-key: your-api-key" ...
+curl -H "x-api-key: your-api-key" http://localhost:8000/api/v1/...
 ```
 
-### YouTube Subtitle Extractor
-
-#### Extract Subtitles
-
-**POST** `/api/v1/subtitles/extract`
+### Subtitles API
 
-Extract subtitles from a YouTube video.
-
-**Request**:
-```json
-{
-  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
-  "lang": "en"
-}
+```bash
+curl -X POST http://localhost:8000/api/v1/subtitles/extract \
+  -H "Content-Type: application/json" \
+  -H "x-api-key: your-key" \
+  -d '{"url": "https://youtube.com/watch?v=VIDEO_ID", "lang": "en"}'
 ```
 
-**Response** (200 OK):
+**Response:**
 ```json
 {
   "status": "success",
+  "video_id": "VIDEO_ID",
   "language": "en",
-  "video_id": "dQw4w9WgXcQ",
-  "subtitles": [
-    "Never gonna give you up",
-    "Never gonna let you down",
-    "Never gonna run around and desert you"
-  ]
+  "subtitles": ["Line 1", "Line 2", "..."]
 }
 ```
 
-**Error Responses**:
-- `400 Bad Request`: Invalid YouTube URL or parameters
-- `401 Unauthorized`: Missing or invalid API key
-- `404 Not Found`: No subtitles available in requested language
-- `408 Request Timeout`: Subtitle extraction timed out
-- `500 Internal Server Error`: yt-dlp error or unexpected failure
-
-**Example Usage**:
+### Embeddings API
 
 ```bash
-# Extract English subtitles
-curl -X POST "http://localhost:8000/api/v1/subtitles/extract" \
+curl -X POST http://localhost:8000/api/v1/embeddings/generate \
   -H "Content-Type: application/json" \
-  -H "x-api-key: your-api-key" \
-  -d '{
-    "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
-    "lang": "en"
-  }'
-
-# Extract Spanish subtitles
-curl -X POST "http://localhost:8000/api/v1/subtitles/extract" \
-  -H "Content-Type: application/json" \
-  -H "x-api-key: your-api-key" \
-  -d '{
-    "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
-    "lang": "es"
-  }'
+  -H "x-api-key: your-key" \
+  -d '{"texts": ["Hello world", "Another text"], "normalize": true}'
 ```
 
-#### Health Check
-
-**GET** `/api/v1/subtitles/health`
-
-Check subtitles service health (no authentication required).
-
-**Response**:
+**Response:**
 ```json
 {
-  "status": "healthy",
-  "service": "subtitles",
-  "yt_dlp_binary": "python -m yt_dlp"
+  "status": "success",
+  "embeddings": [[0.1, 0.2, ...], [0.3, 0.4, ...]],
+  "model": "mixedbread-ai/mxbai-embed-large-v1",
+  "dimensions": 1024
 }
 ```
 
-## 🧪 Testing
-
-Run the test suite:
-
-```bash
-# Run all tests
-poetry run pytest
-
-# Run with coverage
-poetry run pytest --cov=app
-
-# Run specific test file
-poetry run pytest tests/test_subtitles.py
-
-# Run with verbose output
-poetry run pytest -v
-```
-
-## 🏗️ Development
-
-### Project Structure
+## Project Structure
 
 ```
-multi_utility_server/
-├── pyproject.toml           # Poetry config
-├── poetry.lock              # Dependency lock file
-├── README.md
-├── .env.example             # Environment variable template
-├── app/
-│   ├── main.py              # FastAPI app entrypoint
-│   ├── core/
-│   │   ├── config.py        # Environment-based config loader
-│   │   ├── security.py      # API key verification
-│   │   ├── logging.py       # Structured logging setup
-│   │   └── exceptions.py    # Custom exception definitions
-│   ├── apis/
-│   │   ├── __init__.py
-│   │   ├── subtitles/
-│   │   │   ├── router.py    # FastAPI routes
-│   │   │   ├── service.py   # Business logic (yt-dlp, cleaning)
-│   │   │   ├── schemas.py   # Request/response models
-│   │   │   └── utils.py     # Helpers for text cleaning
-│   │   └── <future_api>/
-│   └── middleware/
-│       └── api_key_auth.py  # API key auth middleware
-├── tests/
-│   ├── test_subtitles.py
-│   ├── test_security.py
-│   └── conftest.py
-└── scripts/
-    ├── run_dev.sh           # Linux/macOS dev script
-    └── run_dev.bat          # Windows dev script
+app/
+├── main.py                 # FastAPI application
+├── core/                   # Config, logging, exceptions
+├── middleware/             # Auth, rate limiting
+└── apis/
+    ├── subtitles/          # YouTube subtitle extraction
+    └── embeddings/         # Text embedding generation
 ```
 
-### Adding New APIs
+## Deployment
 
-1. **Create new API module**:
-   ```bash
-   mkdir app/apis/your_new_api
-   touch app/apis/your_new_api/__init__.py
-   touch app/apis/your_new_api/router.py
-   touch app/apis/your_new_api/service.py
-   touch app/apis/your_new_api/schemas.py
-   ```
+### Hugging Face Spaces
 
-2. **Implement your API** following the same pattern as the subtitles API
+1. Create a Docker Space
+2. Set `API_KEYS` secret in Space settings
+3. Push repository
 
-3. **Register the router** in `app/main.py`:
-   ```python
-   from app.apis.your_new_api.router import router as your_new_api_router
-   app.include_router(your_new_api_router)
-   ```
-
-4. **Add tests** in `tests/test_your_new_api.py`
-
-### Code Quality
-
-The project includes several code quality tools:
+### Docker Compose
 
 ```bash
-# Format code
-poetry run black .
-poetry run isort .
-
-# Lint code
-poetry run flake8 .
-
-# Type checking
-poetry run mypy app/
-
-# Run all quality checks
-poetry run black . && poetry run isort . && poetry run flake8 . && poetry run mypy app/
+docker-compose up --build
 ```
 
-## 🚀 Deployment
-
-### Using Docker
-
-The project includes Docker support for easy deployment:
-
-#### Quick Start with Docker Compose
-
-1. **Build and run**:
-   ```bash
-   # Production deployment
-   docker-compose up --build
-   
-   # Development with hot reload
-   docker-compose -f docker-compose.dev.yml up --build
-   ```
-
-2. **Access the application**:
-   - API: http://localhost:8000
-   - Documentation: http://localhost:8000/docs
-   - Health check: http://localhost:8000/health
-
-#### Docker Files Included
-
-- `Dockerfile`: Production-ready container
-- `Dockerfile.dev`: Development container with hot reload
-- `docker-compose.yml`: Basic production setup
-- `docker-compose.dev.yml`: Development setup
-- `docker-compose.prod.yml`: Production setup with resource limits
-- `.dockerignore`: Optimized build context
-
-#### Manual Docker Build
+## Development
 
 ```bash
-# Build production image
-docker build -t multiutility-server .
-
-# Run container
-docker run -p 8000:8000 --env-file .env multiutility-server
-```
+# Run tests
+poetry run pytest
 
-### Using Gunicorn
+# Type checking
+poetry run mypy app/
 
-```bash
-# Production deployment with Gunicorn
-poetry run gunicorn -k uvicorn.workers.UvicornWorker app.main:app \
-  --bind 0.0.0.0:8000 \
-  --workers 4 \
-  --worker-class uvicorn.workers.UvicornWorker \
-  --access-logfile - \
-  --error-logfile -
+# Format code
+poetry run black . && poetry run isort .
 ```
 
-## 🔐 Security Considerations
-
-- **API Keys**: Store API keys securely and rotate them regularly
-- **CORS**: Configure CORS appropriately for your use case
-- **Rate Limiting**: Consider adding rate limiting for production use
-- **HTTPS**: Always use HTTPS in production
-- **Input Validation**: All inputs are validated using Pydantic schemas
-
-## 📊 Monitoring and Logging
-
-The server includes comprehensive logging:
-
-- **Console Logs**: Colored output for development
-- **File Logs**: Rotating log files in `logs/` directory
-- **Error Logs**: Separate error log file
-- **Request Logging**: All HTTP requests are logged
-- **Structured Format**: JSON-like format for easy parsing
-
-Log files:
-- `logs/app.log`: General application logs
-- `logs/error.log`: Error-only logs
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests for new functionality
-5. Run quality checks and tests
-6. Submit a pull request
-
-## 📝 License
-
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-## 🆘 Troubleshooting
-
-### Common Issues
-
-1. **yt-dlp not found**: Ensure yt-dlp is installed: `pip install yt-dlp`
-2. **Permission denied on scripts**: Make scripts executable: `chmod +x scripts/run_dev.sh`
-3. **Port already in use**: Change the port in `.env` file or stop the conflicting service
-4. **API key errors**: Verify your API key is correctly set in the `.env` file
-
-### Getting Help
-
-- Check the logs in `logs/` directory
-- Use the health check endpoints to verify service status
-- Run tests to ensure everything is working: `poetry run pytest`
-- Check the interactive API documentation at `/docs`
-
-## 🔮 Future Enhancements
+## License
 
-- **Rate Limiting**: Per-API-key rate limiting
-- **Metrics**: Prometheus metrics integration
-- **Caching**: Redis caching for frequently requested data
-- **File Upload APIs**: Handle file processing utilities
-- **Webhook Support**: Async webhook notifications
-- **Admin Dashboard**: Web-based administration interface
-- **OAuth2/JWT**: Advanced authentication options
+MIT License - see [LICENSE](LICENSE) for details.

app/__init__.py

@@ -1 +1,3 @@
-# Multi-utility FastAPI Server
+"""Multi-utility FastAPI Server."""
+
+__version__ = "0.1.0"

app/apis/__init__.py

@@ -1 +1,6 @@
-# API modules
+"""API modules."""
+
+from app.apis.subtitles.router import router as subtitles_router
+from app.apis.embeddings.router import router as embeddings_router
+
+__all__ = ["subtitles_router", "embeddings_router"]

app/apis/embeddings/__init__.py

@@ -0,0 +1,6 @@
+"""Embeddings API module."""
+
+from app.apis.embeddings.router import router
+from app.apis.embeddings.service import embedding_service
+
+__all__ = ["router", "embedding_service"]

app/apis/embeddings/router.py

@@ -0,0 +1,51 @@
+"""FastAPI router for embeddings API."""
+
+from fastapi import APIRouter
+
+from app.apis.embeddings.schemas import EmbeddingRequest, EmbeddingResponse
+from app.apis.embeddings.service import embedding_service
+
+
+router = APIRouter(prefix="/api/v1/embeddings", tags=["embeddings"])
+
+
+@router.post(
+    "/generate",
+    response_model=EmbeddingResponse,
+    summary="Generate text embeddings",
+    description="Generate 1024-dimensional embeddings for a list of texts using a local sentence-transformers model."
+)
+async def generate_embeddings(request: EmbeddingRequest) -> EmbeddingResponse:
+    """
+    Generate embeddings for a list of texts.
+
+    Args:
+        request: Contains texts list and optional normalize flag
+
+    Returns:
+        Embedding vectors for each input text
+    """
+    embeddings = embedding_service.generate_embeddings(
+        request.texts,
+        normalize=request.normalize
+    )
+
+    return EmbeddingResponse(
+        embeddings=embeddings,
+        model=embedding_service.model_name,
+        dimensions=embedding_service.dimensions
+    )
+
+
+@router.get(
+    "/health",
+    summary="Health check for embeddings service",
+    description="Check if the embeddings service is operational"
+)
+async def health_check():
+    """Health check endpoint for the embeddings service."""
+    return {
+        "status": "healthy",
+        "service": "embeddings",
+        "model": embedding_service.model_name
+    }

app/apis/embeddings/schemas.py

@@ -0,0 +1,44 @@
+"""Pydantic schemas for embeddings API."""
+
+from typing import List
+from pydantic import BaseModel, field_validator
+
+
+class EmbeddingRequest(BaseModel):
+    """Request model for embedding generation."""
+
+    texts: List[str]
+    normalize: bool = True
+
+    @field_validator("texts")
+    @classmethod
+    def validate_texts(cls, v: List[str]) -> List[str]:
+        """Validate that texts list is not empty and has valid content."""
+        if not v:
+            raise ValueError("texts list cannot be empty")
+        if len(v) > 100:
+            raise ValueError("Maximum 100 texts per request")
+        for i, text in enumerate(v):
+            if not text or not text.strip():
+                raise ValueError(f"Text at index {i} is empty")
+        return v
+
+
+class EmbeddingResponse(BaseModel):
+    """Response model for embedding generation."""
+
+    status: str = "success"
+    embeddings: List[List[float]]
+    model: str
+    dimensions: int
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "status": "success",
+                "embeddings": [[0.1, 0.2, 0.3]],
+                "model": "mixedbread-ai/mxbai-embed-large-v1",
+                "dimensions": 1024
+            }
+        }
+    }

app/apis/embeddings/service.py

@@ -0,0 +1,70 @@
+"""Embedding generation service using sentence-transformers."""
+
+import os
+from typing import List
+import threading
+
+from app.core.config import settings
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+MODELS_DIR = os.environ.get("SENTENCE_TRANSFORMERS_HOME", "models")
+
+
+class EmbeddingService:
+    """Service for generating text embeddings using local models."""
+
+    def __init__(self) -> None:
+        self._model = None
+        self._model_name = settings.embedding_model
+        self._lock = threading.Lock()
+
+    def _load_model(self):
+        """Lazy load the embedding model on first use."""
+        if self._model is None:
+            with self._lock:
+                if self._model is None:
+                    logger.info(f"Loading embedding model: {self._model_name}")
+                    logger.info(f"Models directory: {MODELS_DIR}")
+                    from sentence_transformers import SentenceTransformer
+                    self._model = SentenceTransformer(
+                        self._model_name,
+                        cache_folder=MODELS_DIR
+                    )
+                    logger.info(f"Model loaded. Dimensions: {self._model.get_sentence_embedding_dimension()}")
+
+    def generate_embeddings(self, texts: List[str], normalize: bool = True) -> List[List[float]]:
+        """
+        Generate embeddings for a list of texts.
+
+        Args:
+            texts: List of text strings to embed
+            normalize: Whether to normalize embeddings to unit length
+
+        Returns:
+            List of embedding vectors (each 1024-dimensional)
+        """
+        self._load_model()
+
+        embeddings = self._model.encode(
+            texts,
+            normalize_embeddings=normalize,
+            convert_to_numpy=True
+        )
+
+        return embeddings.tolist()
+
+    @property
+    def model_name(self) -> str:
+        """Get the model name."""
+        return self._model_name
+
+    @property
+    def dimensions(self) -> int:
+        """Get the embedding dimensions."""
+        self._load_model()
+        return self._model.get_sentence_embedding_dimension()
+
+
+embedding_service = EmbeddingService()

app/apis/subtitles/__init__.py

@@ -1 +1,7 @@
-# Subtitles API module
+"""Subtitles API module."""
+
+from app.apis.subtitles.router import router
+from app.apis.subtitles.service import subtitle_service
+from app.apis.subtitles.schemas import SubtitleExtractRequest, SubtitleExtractResponse
+
+__all__ = ["router", "subtitle_service", "SubtitleExtractRequest", "SubtitleExtractResponse"]

app/apis/subtitles/router.py

@@ -1,18 +1,9 @@
 """FastAPI router for subtitles API."""
 
-from fastapi import APIRouter, HTTPException, Header
-from typing import Optional
+from fastapi import APIRouter
 
-from app.apis.subtitles.schemas import SubtitleExtractRequest, SubtitleExtractResponse, SubtitleErrorResponse
+from app.apis.subtitles.schemas import SubtitleExtractRequest, SubtitleExtractResponse
 from app.apis.subtitles.service import subtitle_service
-from app.core.exceptions import (
-    InvalidVideoURLError, 
-    SubtitlesNotFoundError, 
-    DownloadTimeoutError, 
-    SubtitleExtractionError,
-    AuthenticationError
-)
-from app.core.security import get_api_key_from_header
 
 
 router = APIRouter(prefix="/api/v1/subtitles", tags=["subtitles"])
@@ -21,59 +12,29 @@ router = APIRouter(prefix="/api/v1/subtitles", tags=["subtitles"])
 @router.post(
     "/extract",
     response_model=SubtitleExtractResponse,
-    responses={
-        400: {"model": SubtitleErrorResponse, "description": "Bad Request"},
-        401: {"model": SubtitleErrorResponse, "description": "Unauthorized"},
-        404: {"model": SubtitleErrorResponse, "description": "Not Found"},
-        408: {"model": SubtitleErrorResponse, "description": "Request Timeout"},
-        500: {"model": SubtitleErrorResponse, "description": "Internal Server Error"},
-    },
     summary="Extract subtitles from YouTube video",
     description="Extract and clean subtitles from a YouTube video URL. Returns subtitles as a list of text lines."
 )
-async def extract_subtitles(
-    request: SubtitleExtractRequest,
-    x_api_key: Optional[str] = Header(None, description="API key for authentication")
-) -> SubtitleExtractResponse:
+async def extract_subtitles(request: SubtitleExtractRequest) -> SubtitleExtractResponse:
     """
     Extract subtitles from a YouTube video.
-    
-    - **url**: YouTube video URL (youtube.com or youtu.be)
-    - **lang**: Language code for subtitles (default: "en")
-    
-    Returns cleaned subtitle text as a list of strings.
+
+    Args:
+        request: Contains url and optional lang parameter
+
+    Returns:
+        Cleaned subtitle text as a list of strings
     """
-    try:
-        # Validate API key
-        get_api_key_from_header(x_api_key)
-        
-        # Extract subtitles
-        video_id, subtitle_lines = await subtitle_service.extract_subtitles(
-            str(request.url), 
-            request.lang
-        )
-        
-        return SubtitleExtractResponse(
-            language=request.lang,
-            video_id=video_id,
-            subtitles=subtitle_lines
-        )
-        
-    except AuthenticationError as e:
-        raise HTTPException(status_code=401, detail={"status": "error", "message": e.message})
-    except InvalidVideoURLError as e:
-        raise HTTPException(status_code=400, detail={"status": "error", "message": e.message})
-    except SubtitlesNotFoundError as e:
-        raise HTTPException(status_code=404, detail={"status": "error", "message": e.message})
-    except DownloadTimeoutError as e:
-        raise HTTPException(status_code=408, detail={"status": "error", "message": e.message})
-    except SubtitleExtractionError as e:
-        raise HTTPException(status_code=500, detail={"status": "error", "message": e.message})
-    except Exception as e:
-        raise HTTPException(
-            status_code=500, 
-            detail={"status": "error", "message": "An unexpected error occurred"}
-        )
+    video_id, subtitle_lines = await subtitle_service.extract_subtitles(
+        str(request.url),
+        request.lang
+    )
+
+    return SubtitleExtractResponse(
+        language=request.lang,
+        video_id=video_id,
+        subtitles=subtitle_lines
+    )
 
 
 @router.get(
@@ -85,6 +46,5 @@ async def health_check():
     """Health check endpoint for the subtitles service."""
     return {
         "status": "healthy",
-        "service": "subtitles",
-        "yt_dlp_binary": subtitle_service.yt_dlp_binary
+        "service": "subtitles"
     }

app/apis/subtitles/schemas.py

@@ -1,15 +1,15 @@
 """Pydantic schemas for subtitles API."""
 
-from typing import List, Optional
+from typing import List
 from pydantic import BaseModel, HttpUrl, field_validator
 
 
 class SubtitleExtractRequest(BaseModel):
     """Request model for subtitle extraction."""
-    
+
     url: HttpUrl
     lang: str = "en"
-    
+
     @field_validator("url")
     @classmethod
     def validate_youtube_url(cls, v: HttpUrl) -> HttpUrl:
@@ -18,7 +18,7 @@ class SubtitleExtractRequest(BaseModel):
         if not any(domain in url_str for domain in ["youtube.com", "youtu.be"]):
             raise ValueError("URL must be a valid YouTube URL")
         return v
-    
+
     @field_validator("lang")
     @classmethod
     def validate_language(cls, v: str) -> str:
@@ -30,14 +30,14 @@ class SubtitleExtractRequest(BaseModel):
 
 class SubtitleExtractResponse(BaseModel):
     """Response model for successful subtitle extraction."""
-    
+
     status: str = "success"
     language: str
     video_id: str
     subtitles: List[str]
-    
-    class Config:
-        json_schema_extra = {
+
+    model_config = {
+        "json_schema_extra": {
             "example": {
                 "status": "success",
                 "language": "en",
@@ -49,18 +49,4 @@ class SubtitleExtractResponse(BaseModel):
                 ]
             }
         }
-
-
-class SubtitleErrorResponse(BaseModel):
-    """Response model for subtitle extraction errors."""
-    
-    status: str = "error"
-    message: str
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "status": "error",
-                "message": "No subtitles available in the requested language"
-            }
-        }
+    }

app/apis/subtitles/service.py

@@ -1,183 +1,154 @@
-"""Subtitle extraction service using yt-dlp."""
+"""Subtitle extraction service using yt-dlp with caching."""
 
 import asyncio
-import subprocess
 import sys
 import tempfile
 from pathlib import Path
-from typing import List, Optional
-import os
+from typing import List, Optional, Tuple
+
+from cachetools import TTLCache
 
 from app.core.config import settings
 from app.core.exceptions import (
-    InvalidVideoURLError, 
-    SubtitlesNotFoundError, 
-    DownloadTimeoutError, 
-    SubtitleExtractionError
+    SubtitlesNotFoundError,
+    DownloadTimeoutError,
+    SubtitleExtractionError,
+    InvalidVideoURLError
 )
 from app.apis.subtitles.utils import extract_video_id, convert_vtt_to_text
 
 
+SUBTITLE_CACHE: TTLCache = TTLCache(maxsize=100, ttl=3600)
+
+ALTERNATIVE_LANGUAGES = {
+    "en": ["en-US", "en-GB", "en-orig"],
+    "es": ["es-ES", "es-MX", "es-419"],
+    "fr": ["fr-FR", "fr-CA"],
+    "de": ["de-DE"],
+    "it": ["it-IT"],
+    "pt": ["pt-BR", "pt-PT"],
+    "ja": ["ja-JP"],
+    "ko": ["ko-KR"],
+    "zh": ["zh-CN", "zh-TW", "zh-Hans", "zh-Hant"]
+}
+
+
 class SubtitleService:
     """Service for extracting subtitles from YouTube videos."""
-    
-    def __init__(self):
-        self.yt_dlp_binary = settings.yt_dlp_binary
+
+    def __init__(self) -> None:
         self.timeout_list = settings.yt_dlp_timeout_list
         self.timeout_download = settings.yt_dlp_timeout_download
-    
-    async def extract_subtitles(self, url: str, lang: str = "en") -> tuple[str, List[str]]:
+
+    async def extract_subtitles(self, url: str, lang: str = "en") -> Tuple[str, List[str]]:
         """
         Extract subtitles from a YouTube video.
-        
+
         Args:
             url: YouTube video URL
             lang: Language code for subtitles
-            
+
         Returns:
             Tuple of (video_id, subtitle_lines)
-            
+
         Raises:
-            InvalidVideoURLError: If the URL is invalid
             SubtitlesNotFoundError: If no subtitles are found
             DownloadTimeoutError: If the operation times out
             SubtitleExtractionError: If extraction fails
         """
         video_id = extract_video_id(url)
-        
-        # Create temporary directory for subtitle files
+        cache_key = f"{video_id}:{lang}"
+
+        if cache_key in SUBTITLE_CACHE:
+            return SUBTITLE_CACHE[cache_key]
+
         with tempfile.TemporaryDirectory() as temp_dir:
-            try:
-                # First, try to list available subtitles
-                await self._check_available_subtitles(url)
-                
-                # Download subtitles
-                subtitle_content = await self._download_subtitles(url, lang, temp_dir, video_id)
-                
-                if not subtitle_content:
-                    # Try alternative language codes
-                    alt_langs = self._get_alternative_languages(lang)
-                    for alt_lang in alt_langs:
-                        subtitle_content = await self._download_subtitles(url, alt_lang, temp_dir, video_id)
-                        if subtitle_content:
-                            lang = alt_lang  # Update the language that worked
-                            break
-                
-                if not subtitle_content:
-                    raise SubtitlesNotFoundError(f"No subtitles available in language '{lang}' or alternatives")
-                
-                # Convert and clean subtitles
-                clean_lines = convert_vtt_to_text(subtitle_content)
-                
-                if not clean_lines:
-                    raise SubtitlesNotFoundError("Subtitles found but appear to be empty after cleaning")
-                
-                return video_id, clean_lines
-                
-            except (InvalidVideoURLError, SubtitlesNotFoundError, DownloadTimeoutError):
-                raise
-            except Exception as e:
-                raise SubtitleExtractionError(f"Unexpected error during subtitle extraction: {str(e)}")
-    
-    async def _check_available_subtitles(self, url: str) -> None:
-        """Check if subtitles are available for the video."""
-        try:
-            cmd = [
-                sys.executable, "-m", "yt_dlp",
-                "--list-subs",
-                "--no-warnings",
-                url
-            ]
-            
-            process = await asyncio.create_subprocess_exec(
-                *cmd,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(), 
-                timeout=self.timeout_list
-            )
-            
-            if process.returncode != 0:
-                error_msg = stderr.decode('utf-8', errors='ignore')
-                if "Video unavailable" in error_msg or "Private video" in error_msg:
-                    raise InvalidVideoURLError("Video is unavailable, private, or does not exist")
-                raise SubtitleExtractionError(f"Failed to check subtitles: {error_msg}")
-                
-        except asyncio.TimeoutError:
-            raise DownloadTimeoutError("Timeout while checking available subtitles")
-        except (InvalidVideoURLError, SubtitleExtractionError):
-            raise
-        except Exception as e:
-            raise SubtitleExtractionError(f"Error checking subtitles: {str(e)}")
-    
-    async def _download_subtitles(self, url: str, lang: str, temp_dir: str, video_id: str) -> Optional[str]:
+            subtitle_content = await self._download_subtitles(url, lang, temp_dir, video_id)
+
+            if not subtitle_content:
+                subtitle_content = await self._try_alternative_languages(url, lang, temp_dir, video_id)
+
+            if not subtitle_content:
+                raise SubtitlesNotFoundError(f"No subtitles available in language '{lang}' or alternatives")
+
+            clean_lines = convert_vtt_to_text(subtitle_content)
+
+            if not clean_lines:
+                raise SubtitlesNotFoundError("Subtitles found but appear to be empty after cleaning")
+
+            result = (video_id, clean_lines)
+            SUBTITLE_CACHE[cache_key] = result
+            return result
+
+    async def _try_alternative_languages(
+        self, url: str, lang: str, temp_dir: str, video_id: str
+    ) -> Optional[str]:
+        """Try downloading subtitles in alternative language codes concurrently."""
+        alt_langs = ALTERNATIVE_LANGUAGES.get(lang, [f"{lang}-{lang.upper()}"])
+
+        tasks = [
+            self._download_subtitles(url, alt_lang, temp_dir, video_id)
+            for alt_lang in alt_langs
+        ]
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for result in results:
+            if isinstance(result, str) and result:
+                return result
+
+        return None
+
+    async def _download_subtitles(
+        self, url: str, lang: str, temp_dir: str, video_id: str
+    ) -> Optional[str]:
         """Download subtitles for a specific language."""
+        output_template = str(Path(temp_dir) / f"{video_id}.%(ext)s")
+
+        cmd = [
+            sys.executable, "-m", "yt_dlp",
+            "--write-subs",
+            "--write-auto-subs",
+            "--sub-lang", lang,
+            "--skip-download",
+            "--no-warnings",
+            "--output", output_template,
+            "--user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            url
+        ]
+
         try:
-            output_template = os.path.join(temp_dir, f"{video_id}.%(ext)s")
-            
-            cmd = [
-                sys.executable, "-m", "yt_dlp",
-                "--write-subs",
-                "--write-auto-subs",  # Also try auto-generated subs
-                "--sub-lang", lang,
-                "--skip-download",
-                "--no-warnings",
-                "--output", output_template,
-                "--user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-                url
-            ]
-            
             process = await asyncio.create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE
             )
-            
+
             stdout, stderr = await asyncio.wait_for(
                 process.communicate(),
                 timeout=self.timeout_download
             )
-            
+
             if process.returncode != 0:
-                # This is expected if subtitles aren't available in this language
+                error_msg = stderr.decode('utf-8', errors='ignore')
+                if "Video unavailable" in error_msg or "Private video" in error_msg:
+                    raise InvalidVideoURLError("Video is unavailable, private, or does not exist")
                 return None
-            
-            # Look for downloaded subtitle files
+
             temp_path = Path(temp_dir)
             subtitle_files = list(temp_path.glob(f"{video_id}*.vtt"))
-            
+
             if not subtitle_files:
                 return None
-            
-            # Read the first subtitle file found
-            with open(subtitle_files[0], 'r', encoding='utf-8', errors='ignore') as f:
-                return f.read()
-                
+
+            return subtitle_files[0].read_text(encoding='utf-8', errors='ignore')
+
         except asyncio.TimeoutError:
             raise DownloadTimeoutError(f"Timeout while downloading subtitles for language '{lang}'")
-        except Exception:
-            # Return None to allow trying other languages
-            return None
-    
-    def _get_alternative_languages(self, lang: str) -> List[str]:
-        """Get alternative language codes to try."""
-        alternatives = {
-            "en": ["en-US", "en-GB", "en-orig"],
-            "es": ["es-ES", "es-MX", "es-419"],
-            "fr": ["fr-FR", "fr-CA"],
-            "de": ["de-DE"],
-            "it": ["it-IT"],
-            "pt": ["pt-BR", "pt-PT"],
-            "ja": ["ja-JP"],
-            "ko": ["ko-KR"],
-            "zh": ["zh-CN", "zh-TW", "zh-Hans", "zh-Hant"]
-        }
-        
-        return alternatives.get(lang, [f"{lang}-{lang.upper()}"])
-
-
-# Global service instance
+        except (InvalidVideoURLError, DownloadTimeoutError):
+            raise
+        except Exception as e:
+            raise SubtitleExtractionError(f"Error downloading subtitles: {str(e)}")
+
+
 subtitle_service = SubtitleService()

app/core/__init__.py

@@ -1 +1,26 @@
-# Core modules
+"""Core module exports."""
+
+from app.core.config import settings
+from app.core.exceptions import (
+    MultiUtilityServerException,
+    AuthenticationError,
+    InvalidVideoURLError,
+    SubtitlesNotFoundError,
+    DownloadTimeoutError,
+    SubtitleExtractionError
+)
+from app.core.logging import setup_logging, get_logger
+from app.core.security import verify_api_key
+
+__all__ = [
+    "settings",
+    "MultiUtilityServerException",
+    "AuthenticationError",
+    "InvalidVideoURLError",
+    "SubtitlesNotFoundError",
+    "DownloadTimeoutError",
+    "SubtitleExtractionError",
+    "setup_logging",
+    "get_logger",
+    "verify_api_key"
+]

app/core/config.py

@@ -1,56 +1,65 @@
 """Configuration module for the multi-utility server."""
 
-import os
-from typing import Set
+from typing import List, Set
+from pydantic import computed_field, field_validator
 from pydantic_settings import BaseSettings
-from pydantic import field_validator
 
 
 class Settings(BaseSettings):
     """Application settings loaded from environment variables."""
-    
-    # API Security
-    api_keys: str = "default-key-1,default-key-2"
-    
+
+    # API Security - no default keys for security
+    api_keys: str = ""
+
+    # CORS Configuration
+    cors_origins: str = ""
+
+    # Rate Limiting
+    rate_limit_requests: int = 100
+    rate_limit_window: int = 60
+
     # Logging
     log_level: str = "INFO"
-    
+
     # yt-dlp configuration
-    yt_dlp_binary: str = "python -m yt_dlp"
-    yt_dlp_timeout_list: int = 30  # seconds for listing subtitles
-    yt_dlp_timeout_download: int = 60  # seconds for downloading subtitles
-    
+    yt_dlp_timeout_list: int = 30
+    yt_dlp_timeout_download: int = 60
+
+    # Embedding configuration
+    embedding_model: str = "mixedbread-ai/mxbai-embed-large-v1"
+
     # Server configuration
     host: str = "0.0.0.0"
     port: int = 8000
-    reload: bool = False  # Default to False for production
-    
-    class Config:
-        env_file = ".env"
-        env_file_encoding = "utf-8"
-    
-    @field_validator("api_keys")
-    @classmethod
-    def parse_api_keys(cls, v: str) -> Set[str]:
-        """Convert comma-separated API keys to a set."""
-        return {key.strip() for key in v.split(",") if key.strip()}
-    
+    reload: bool = False
+
+    model_config = {"env_file": ".env", "env_file_encoding": "utf-8"}
+
+    @computed_field
     @property
     def api_keys_set(self) -> Set[str]:
         """Get API keys as a set."""
-        if isinstance(self.api_keys, str):
-            return {key.strip() for key in self.api_keys.split(",") if key.strip()}
-        return self.api_keys
-    
+        if not self.api_keys:
+            return set()
+        return {key.strip() for key in self.api_keys.split(",") if key.strip()}
+
+    @computed_field
+    @property
+    def cors_origins_list(self) -> List[str]:
+        """Get CORS origins as a list."""
+        if not self.cors_origins:
+            return ["*"]
+        return [origin.strip() for origin in self.cors_origins.split(",") if origin.strip()]
+
     @field_validator("log_level")
     @classmethod
     def validate_log_level(cls, v: str) -> str:
         """Validate log level."""
         valid_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
-        if v.upper() not in valid_levels:
+        upper_v = v.upper()
+        if upper_v not in valid_levels:
             raise ValueError(f"Invalid log level: {v}. Must be one of {valid_levels}")
-        return v.upper()
+        return upper_v
 
 
-# Global settings instance
 settings = Settings()

app/core/security.py

@@ -1,44 +1,31 @@
 """Security utilities for API key verification."""
 
-from typing import Optional
+import secrets
 from app.core.config import settings
 from app.core.exceptions import AuthenticationError
 
 
-def verify_api_key(api_key: Optional[str]) -> bool:
+def verify_api_key(api_key: str) -> bool:
     """
-    Verify if the provided API key is valid.
-    
+    Verify if the provided API key is valid using timing-safe comparison.
+
     Args:
         api_key: The API key to verify
-        
+
     Returns:
         True if the API key is valid
-        
+
     Raises:
         AuthenticationError: If the API key is invalid or missing
     """
     if not api_key:
         raise AuthenticationError("Missing API key")
-    
-    if api_key not in settings.api_keys_set:
-        raise AuthenticationError("Invalid API key")
-    
-    return True
 
+    if not settings.api_keys_set:
+        raise AuthenticationError("No API keys configured on server")
 
-def get_api_key_from_header(x_api_key: Optional[str]) -> str:
-    """
-    Extract and validate API key from header.
-    
-    Args:
-        x_api_key: The X-API-Key header value
-        
-    Returns:
-        The validated API key
-        
-    Raises:
-        AuthenticationError: If the API key is invalid or missing
-    """
-    verify_api_key(x_api_key)
-    return x_api_key
+    for valid_key in settings.api_keys_set:
+        if secrets.compare_digest(api_key, valid_key):
+            return True
+
+    raise AuthenticationError("Invalid API key")

app/main.py

@@ -1,18 +1,21 @@
 """Main FastAPI application for the multi-utility server."""
 
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
 import time
 from contextlib import asynccontextmanager
 
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+
 from app.core.config import settings
 from app.core.logging import setup_logging, get_logger
 from app.core.exceptions import MultiUtilityServerException
-from app.middleware.api_key_auth import APIKeyMiddleware
+from app.middleware import APIKeyMiddleware, limiter
 from app.apis.subtitles.router import router as subtitles_router
+from app.apis.embeddings.router import router as embeddings_router
 
-# Set up logging
 setup_logging()
 logger = get_logger(__name__)
 
@@ -23,11 +26,11 @@ async def lifespan(app: FastAPI):
     logger.info("Starting multi-utility server...")
     logger.info(f"Log level: {settings.log_level}")
     logger.info(f"API keys configured: {len(settings.api_keys_set)}")
+    logger.info(f"CORS origins: {settings.cors_origins_list}")
     yield
     logger.info("Shutting down multi-utility server...")
 
 
-# Create FastAPI application
 app = FastAPI(
     title="Multi-Utility Server",
     description="Centralized FastAPI server providing reusable APIs for different projects",
@@ -37,20 +40,20 @@ app = FastAPI(
     lifespan=lifespan
 )
 
-# Add CORS middleware
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Configure appropriately for production
-    allow_credentials=True,
-    allow_methods=["*"],
+    allow_origins=settings.cors_origins_list,
+    allow_credentials=True if settings.cors_origins else False,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
     allow_headers=["*"],
 )
 
-# Add API key authentication middleware
 app.add_middleware(APIKeyMiddleware)
 
 
-# Custom exception handler
 @app.exception_handler(MultiUtilityServerException)
 async def custom_exception_handler(request: Request, exc: MultiUtilityServerException):
     """Handle custom application exceptions."""
@@ -61,7 +64,6 @@ async def custom_exception_handler(request: Request, exc: MultiUtilityServerExce
     )
 
 
-# Global exception handler
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
     """Handle unexpected exceptions."""
@@ -72,18 +74,14 @@ async def global_exception_handler(request: Request, exc: Exception):
     )
 
 
-# Request logging middleware
 @app.middleware("http")
 async def log_requests(request: Request, call_next):
     """Log all HTTP requests."""
     start_time = time.time()
-    
-    # Log request
     logger.info(f"Request: {request.method} {request.url.path}")
     
     response = await call_next(request)
     
-    # Log response
     process_time = time.time() - start_time
     logger.info(
         f"Response: {response.status_code} | "
@@ -94,7 +92,6 @@ async def log_requests(request: Request, call_next):
     return response
 
 
-# Health check endpoint
 @app.get("/health")
 async def health_check():
     """Health check endpoint."""
@@ -105,23 +102,23 @@ async def health_check():
     }
 
 
-# Root endpoint
 @app.get("/")
 async def root():
-    """Root endpoint with basic information."""
+    """Root endpoint with API information."""
     return {
         "message": "Multi-Utility FastAPI Server",
         "version": "0.1.0",
         "docs": "/docs",
         "health": "/health",
         "apis": {
-            "subtitles": "/api/v1/subtitles"
+            "subtitles": "/api/v1/subtitles",
+            "embeddings": "/api/v1/embeddings"
         }
     }
 
 
-# Include API routers
 app.include_router(subtitles_router)
+app.include_router(embeddings_router)
 
 
 if __name__ == "__main__":

app/middleware/__init__.py

@@ -1 +1,6 @@
-# Middleware modules
+"""Middleware module exports."""
+
+from app.middleware.api_key_auth import APIKeyMiddleware
+from app.middleware.rate_limit import limiter, rate_limit_exceeded_handler
+
+__all__ = ["APIKeyMiddleware", "limiter", "rate_limit_exceeded_handler"]

app/middleware/api_key_auth.py

@@ -1,72 +1,56 @@
 """API key authentication middleware."""
 
-from typing import Optional
-from fastapi import Request, HTTPException
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+import secrets
+from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 
 from app.core.config import settings
-from app.core.exceptions import AuthenticationError
+
+
+EXEMPT_PATHS = frozenset([
+    "/",
+    "/health",
+    "/docs",
+    "/redoc",
+    "/openapi.json",
+    "/api/v1/subtitles/health",
+    "/api/v1/embeddings/health"
+])
 
 
 class APIKeyMiddleware(BaseHTTPMiddleware):
     """Middleware to enforce API key authentication."""
-    
+
     async def dispatch(self, request: Request, call_next):
-        # Skip authentication for health check and docs endpoints
-        if request.url.path in ["/", "/health", "/docs", "/redoc", "/openapi.json"]:
-            response = await call_next(request)
-            return response
-        
-        # Extract API key from header
+        """Process request and validate API key for protected endpoints."""
+        if request.url.path in EXEMPT_PATHS:
+            return await call_next(request)
+
         api_key = request.headers.get("x-api-key")
-        
+
         if not api_key:
             return JSONResponse(
                 status_code=401,
-                content={
-                    "status": "error", 
-                    "message": "Missing API key. Include 'x-api-key' header."
-                }
+                content={"status": "error", "message": "Missing API key. Include 'x-api-key' header."}
             )
-        
-        if api_key not in settings.api_keys_set:
+
+        if not settings.api_keys_set:
             return JSONResponse(
-                status_code=401,
-                content={
-                    "status": "error", 
-                    "message": "Invalid API key"
-                }
+                status_code=500,
+                content={"status": "error", "message": "No API keys configured on server"}
             )
-        
-        # Add API key to request state for potential logging
-        request.state.api_key = api_key
-        
-        response = await call_next(request)
-        return response
 
+        is_valid = any(
+            secrets.compare_digest(api_key, valid_key)
+            for valid_key in settings.api_keys_set
+        )
 
-# Alternative dependency-based approach for specific routes
-api_key_header = HTTPBearer(scheme_name="API Key", description="API Key required in Authorization header")
-
+        if not is_valid:
+            return JSONResponse(
+                status_code=401,
+                content={"status": "error", "message": "Invalid API key"}
+            )
 
-async def get_api_key(credentials: HTTPAuthorizationCredentials = api_key_header) -> str:
-    """
-    Dependency to extract and validate API key from Authorization header.
-    
-    Args:
-        credentials: HTTP authorization credentials
-        
-    Returns:
-        The validated API key
-        
-    Raises:
-        HTTPException: If the API key is invalid
-    """
-    if not credentials or credentials.credentials not in settings.api_keys_set:
-        raise HTTPException(
-            status_code=401,
-            detail="Invalid API key"
-        )
-    return credentials.credentials
+        request.state.api_key = api_key
+        return await call_next(request)

app/middleware/rate_limit.py

@@ -0,0 +1,27 @@
+"""Rate limiting middleware using slowapi."""
+
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+from slowapi.middleware import SlowAPIMiddleware
+from starlette.responses import JSONResponse
+from starlette.requests import Request
+
+from app.core.config import settings
+
+
+limiter = Limiter(
+    key_func=get_remote_address,
+    default_limits=[f"{settings.rate_limit_requests}/minute"]
+)
+
+
+def rate_limit_exceeded_handler(request: Request, exc: RateLimitExceeded) -> JSONResponse:
+    """Handle rate limit exceeded errors."""
+    return JSONResponse(
+        status_code=429,
+        content={
+            "status": "error",
+            "message": f"Rate limit exceeded. Try again in {exc.detail} seconds."
+        }
+    )

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "multi-utility-server"
-version = "0.1.0"
+version = "1.0.0"
 description = "Centralized multi-utility FastAPI server with reusable APIs"
 authors = ["Abhishek Sharma <abhishek@abhisheksan.com>"]
 readme = "README.md"
@@ -15,6 +15,10 @@ pydantic-settings = "^2.1.0"
 yt-dlp = "^2025.9.5"
 python-dotenv = "^1.0.0"
 loguru = "^0.7.2"
+slowapi = "^0.1.9"
+cachetools = "^5.3.0"
+sentence-transformers = "^2.2.2"
+torch = "^2.0.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.4.3"

scripts/run_dev.bat

@@ -1,38 +0,0 @@
-@echo off
-REM Development script for running the multi-utility server on Windows
-
-echo Starting Multi-Utility Server Development Environment
-
-REM Check if Poetry is installed
-poetry --version >nul 2>&1
-if %errorlevel% neq 0 (
-    echo Poetry is not installed. Please install Poetry first.
-    echo Visit: https://python-poetry.org/docs/#installation
-    pause
-    exit /b 1
-)
-
-REM Install dependencies if not already installed
-if not exist ".venv" (
-    echo Installing dependencies...
-    poetry install
-)
-
-REM Create .env file if it doesn't exist
-if not exist ".env" (
-    echo Creating .env file from template...
-    copy .env.example .env
-    echo Please edit .env file to configure your API keys and settings.
-)
-
-REM Create logs directory
-if not exist "logs" mkdir logs
-
-REM Start the development server
-echo Starting development server...
-echo Server will be available at: http://localhost:8000
-echo API documentation: http://localhost:8000/docs
-echo Press Ctrl+C to stop the server
-echo.
-
-poetry run python -m uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

scripts/run_dev.sh

@@ -1,42 +0,0 @@
-#!/bin/bash
-# Development script for running the multi-utility server
-
-# Colors for output
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-echo -e "${GREEN}Starting Multi-Utility Server Development Environment${NC}"
-
-# Check if Poetry is installed
-if ! command -v poetry &> /dev/null; then
-    echo -e "${RED}Poetry is not installed. Please install Poetry first.${NC}"
-    echo "Visit: https://python-poetry.org/docs/#installation"
-    exit 1
-fi
-
-# Install dependencies if not already installed
-if [ ! -d ".venv" ]; then
-    echo -e "${YELLOW}Installing dependencies...${NC}"
-    poetry install
-fi
-
-# Create .env file if it doesn't exist
-if [ ! -f ".env" ]; then
-    echo -e "${YELLOW}Creating .env file from template...${NC}"
-    cp .env.example .env
-    echo -e "${YELLOW}Please edit .env file to configure your API keys and settings.${NC}"
-fi
-
-# Create logs directory
-mkdir -p logs
-
-# Start the development server
-echo -e "${GREEN}Starting development server...${NC}"
-echo -e "${YELLOW}Server will be available at: http://localhost:8000${NC}"
-echo -e "${YELLOW}API documentation: http://localhost:8000/docs${NC}"
-echo -e "${YELLOW}Press Ctrl+C to stop the server${NC}"
-echo ""
-
-poetry run python -m uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

scripts/run_docker.bat

@@ -1,20 +0,0 @@
-@echo off
-echo Building and running Multi-Utility Server with Docker...
-echo.
-
-REM Change to project root directory
-cd /d "%~dp0\.."
-
-REM Check if .env file exists
-if not exist .env (
-    echo Warning: .env file not found. Copying from .env.example...
-    copy .env.example .env
-    echo Please edit .env file with your API keys before running again.
-    pause
-    exit /b 1
-)
-
-REM Build and run with docker-compose
-docker-compose up --build
-
-pause

scripts/run_docker.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-echo "Building and running Multi-Utility Server with Docker..."
-echo
-
-# Change to project root directory
-cd "$(dirname "$0")/.."
-
-# Check if .env file exists
-if [ ! -f .env ]; then
-    echo "Warning: .env file not found. Copying from .env.example..."
-    cp .env.example .env
-    echo "Please edit .env file with your API keys before running again."
-    exit 1
-fi
-
-# Build and run with docker-compose
-docker-compose up --build

tests/conftest.py

@@ -2,10 +2,13 @@
 
 import pytest
 from fastapi.testclient import TestClient
-from unittest.mock import Mock, patch
+from unittest.mock import patch
 import tempfile
 import os
 
+# Ensure API_KEYS is set for testing
+os.environ.setdefault("API_KEYS", "test-key-1,test-key-2")
+
 from app.main import app
 from app.core.config import settings
 
@@ -29,13 +32,6 @@ def invalid_api_key():
     return "invalid-key-for-testing"
 
 
-@pytest.fixture
-def mock_subprocess():
-    """Mock subprocess calls for yt-dlp."""
-    with patch('subprocess.run') as mock_run:
-        yield mock_run
-
-
 @pytest.fixture
 def mock_asyncio_subprocess():
     """Mock asyncio subprocess calls for yt-dlp."""

tests/test_security.py

@@ -4,57 +4,46 @@ from unittest import mock
 import pytest
 from fastapi.testclient import TestClient
 
-from app.core.security import verify_api_key, get_api_key_from_header
+from app.core.security import verify_api_key
 from app.core.exceptions import AuthenticationError
-from app.main import app
 
 
 class TestAPIKeySecurity:
     """Test API key security functions."""
-    
+
     def test_verify_api_key_valid(self, api_key):
         """Test verifying a valid API key."""
         assert verify_api_key(api_key) is True
-    
+
     def test_verify_api_key_invalid(self, invalid_api_key):
         """Test verifying an invalid API key."""
         with pytest.raises(AuthenticationError):
             verify_api_key(invalid_api_key)
-    
-    def test_verify_api_key_none(self):
-        """Test verifying None API key."""
-        with pytest.raises(AuthenticationError):
-            verify_api_key(None)
-    
-    def test_get_api_key_from_header_valid(self, api_key):
-        """Test getting API key from valid header."""
-        result = get_api_key_from_header(api_key)
-        assert result == api_key
-    
-    def test_get_api_key_from_header_invalid(self, invalid_api_key):
-        """Test getting API key from invalid header."""
+
+    def test_verify_api_key_empty(self):
+        """Test verifying empty API key."""
         with pytest.raises(AuthenticationError):
-            get_api_key_from_header(invalid_api_key)
+            verify_api_key("")
 
 
 class TestAPIKeyMiddleware:
     """Test API key middleware functionality."""
-    
+
     def test_middleware_allows_health_endpoint(self, client):
         """Test that middleware allows access to health endpoint without API key."""
         response = client.get("/health")
         assert response.status_code == 200
-    
+
     def test_middleware_allows_docs_endpoint(self, client):
         """Test that middleware allows access to docs endpoint without API key."""
         response = client.get("/docs")
         assert response.status_code == 200
-    
+
     def test_middleware_allows_root_endpoint(self, client):
         """Test that middleware allows access to root endpoint without API key."""
         response = client.get("/")
         assert response.status_code == 200
-    
+
     def test_middleware_blocks_api_without_key(self, client):
         """Test that middleware blocks API access without API key."""
         response = client.post(
@@ -65,7 +54,7 @@ class TestAPIKeyMiddleware:
         data = response.json()
         assert data["status"] == "error"
         assert "Missing API key" in data["message"]
-    
+
     def test_middleware_blocks_api_with_invalid_key(self, client, invalid_api_key):
         """Test that middleware blocks API access with invalid API key."""
         response = client.post(
@@ -77,13 +66,12 @@ class TestAPIKeyMiddleware:
         data = response.json()
         assert data["status"] == "error"
         assert "Invalid API key" in data["message"]
-    
+
     def test_middleware_allows_api_with_valid_key(self, client, api_key):
         """Test that middleware allows API access with valid API key."""
-        # Mock the subtitle service to avoid actual yt-dlp calls
         with mock.patch('app.apis.subtitles.service.subtitle_service.extract_subtitles') as mock_extract:
             mock_extract.return_value = ("dQw4w9WgXcQ", ["Test subtitle"])
-            
+
             response = client.post(
                 "/api/v1/subtitles/extract",
                 json={"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "lang": "en"},

tests/test_subtitles.py

@@ -1,42 +1,39 @@
 """Tests for subtitle extraction functionality."""
 
 import pytest
-from unittest.mock import Mock, AsyncMock, patch, mock_open
+from unittest.mock import AsyncMock, patch
 import asyncio
-from pathlib import Path
 
-from app.apis.subtitles.service import SubtitleService
+from app.apis.subtitles.service import SubtitleService, SUBTITLE_CACHE
 from app.apis.subtitles.utils import (
-    clean_subtitle_text, 
-    extract_video_id, 
+    clean_subtitle_text,
+    extract_video_id,
     convert_vtt_to_text
 )
 from app.core.exceptions import (
-    InvalidVideoURLError, 
-    SubtitlesNotFoundError, 
-    DownloadTimeoutError, 
-    SubtitleExtractionError
+    SubtitlesNotFoundError,
+    DownloadTimeoutError
 )
 
 
 class TestSubtitleUtils:
     """Test subtitle utility functions."""
-    
+
     def test_extract_video_id_standard_url(self):
         """Test extracting video ID from standard YouTube URL."""
         url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
         assert extract_video_id(url) == "dQw4w9WgXcQ"
-    
+
     def test_extract_video_id_short_url(self):
         """Test extracting video ID from short YouTube URL."""
         url = "https://youtu.be/dQw4w9WgXcQ"
         assert extract_video_id(url) == "dQw4w9WgXcQ"
-    
+
     def test_extract_video_id_embed_url(self):
         """Test extracting video ID from embed URL."""
         url = "https://www.youtube.com/embed/dQw4w9WgXcQ"
         assert extract_video_id(url) == "dQw4w9WgXcQ"
-    
+
     def test_clean_subtitle_text(self):
         """Test cleaning subtitle text."""
         raw_lines = [
@@ -46,24 +43,24 @@ class TestSubtitleUtils:
             "00:00:00.000 --> 00:00:03.000",
             "Never gonna give you up",
             "",
-            "2", 
+            "2",
             "00:00:03.000 --> 00:00:06.000",
             "Never gonna let you down",
-            "Never gonna give you up",  # Duplicate
+            "Never gonna give you up",
             ""
         ]
-        
+
         cleaned = clean_subtitle_text(raw_lines)
         assert "Never gonna give you up" in cleaned
         assert "Never gonna let you down" in cleaned
         assert "WEBVTT" not in cleaned
         assert "00:00:00.000 --> 00:00:03.000" not in cleaned
         assert len([line for line in cleaned if line == "Never gonna give you up"]) == 1
-    
+
     def test_convert_vtt_to_text(self, sample_vtt_content):
         """Test converting VTT content to clean text."""
         result = convert_vtt_to_text(sample_vtt_content)
-        
+
         assert "Never gonna give you up" in result
         assert "Never gonna let you down" in result
         assert "WEBVTT" not in result
@@ -72,109 +69,73 @@ class TestSubtitleUtils:
 
 class TestSubtitleService:
     """Test subtitle extraction service."""
-    
+
+    @pytest.fixture(autouse=True)
+    def clear_cache(self):
+        """Clear cache before each test."""
+        SUBTITLE_CACHE.clear()
+
     @pytest.fixture
     def service(self):
         """Create a subtitle service instance."""
         return SubtitleService()
-    
+
     @pytest.mark.asyncio
     async def test_extract_subtitles_success(self, service, sample_youtube_url, sample_vtt_content):
         """Test successful subtitle extraction."""
-        with patch.object(service, '_check_available_subtitles') as mock_check, \
-             patch.object(service, '_download_subtitles') as mock_download:
-            
-            mock_check.return_value = None
+        with patch.object(service, '_download_subtitles') as mock_download:
             mock_download.return_value = sample_vtt_content
-            
+
             video_id, subtitles = await service.extract_subtitles(sample_youtube_url, "en")
-            
+
             assert video_id == "dQw4w9WgXcQ"
             assert len(subtitles) > 0
             assert "Never gonna give you up" in subtitles
-    
+
     @pytest.mark.asyncio
     async def test_extract_subtitles_not_found(self, service, sample_youtube_url):
         """Test subtitle extraction when no subtitles are found."""
-        with patch.object(service, '_check_available_subtitles') as mock_check, \
-             patch.object(service, '_download_subtitles') as mock_download:
-            
-            mock_check.return_value = None
+        with patch.object(service, '_download_subtitles') as mock_download, \
+             patch.object(service, '_try_alternative_languages') as mock_alt:
             mock_download.return_value = None
-            
+            mock_alt.return_value = None
+
             with pytest.raises(SubtitlesNotFoundError):
                 await service.extract_subtitles(sample_youtube_url, "en")
-    
-    @pytest.mark.asyncio
-    async def test_extract_subtitles_timeout(self, service, sample_youtube_url):
-        """Test subtitle extraction timeout."""
-        with patch.object(service, '_check_available_subtitles') as mock_check:
-            mock_check.side_effect = asyncio.TimeoutError()
-            
-            with pytest.raises(DownloadTimeoutError):
-                await service.extract_subtitles(sample_youtube_url, "en")
-    
-    @pytest.mark.asyncio
-    async def test_check_available_subtitles_success(self, service, sample_youtube_url):
-        """Test checking available subtitles."""
-        mock_process = AsyncMock()
-        mock_process.returncode = 0
-        mock_process.communicate.return_value = (b"Subtitle output", b"")
-        
-        with patch('asyncio.create_subprocess_exec', return_value=mock_process), \
-             patch('asyncio.wait_for', return_value=(b"Subtitle output", b"")):
-            
-            # Should not raise any exception
-            await service._check_available_subtitles(sample_youtube_url)
-    
+
     @pytest.mark.asyncio
-    async def test_check_available_subtitles_invalid_video(self, service):
-        """Test checking subtitles for invalid video."""
-        mock_process = AsyncMock()
-        mock_process.returncode = 1
-        mock_process.communicate.return_value = (b"", b"Video unavailable")
-        
-        with patch('asyncio.create_subprocess_exec', return_value=mock_process), \
-             patch('asyncio.wait_for', return_value=(b"", b"Video unavailable")):
-            
-            with pytest.raises(InvalidVideoURLError):
-                await service._check_available_subtitles("https://www.youtube.com/watch?v=invalid")
-    
-    def test_get_alternative_languages(self, service):
-        """Test getting alternative language codes."""
-        alternatives = service._get_alternative_languages("en")
-        assert "en-US" in alternatives
-        assert "en-GB" in alternatives
-        
-        alternatives = service._get_alternative_languages("es")
-        assert "es-ES" in alternatives
-        assert "es-MX" in alternatives
-        
-        # Test unknown language
-        alternatives = service._get_alternative_languages("unknown")
-        assert "unknown-UNKNOWN" in alternatives
+    async def test_extract_subtitles_uses_cache(self, service, sample_youtube_url, sample_vtt_content):
+        """Test that cached results are returned."""
+        with patch.object(service, '_download_subtitles') as mock_download:
+            mock_download.return_value = sample_vtt_content
+
+            result1 = await service.extract_subtitles(sample_youtube_url, "en")
+            result2 = await service.extract_subtitles(sample_youtube_url, "en")
+
+            assert result1 == result2
+            assert mock_download.call_count == 1
 
 
 class TestSubtitleAPI:
     """Test subtitle API endpoints."""
-    
+
     def test_extract_subtitles_endpoint_success(self, client, api_key, sample_vtt_content):
         """Test successful subtitle extraction via API."""
         with patch('app.apis.subtitles.service.subtitle_service.extract_subtitles') as mock_extract:
             mock_extract.return_value = ("dQw4w9WgXcQ", ["Never gonna give you up", "Never gonna let you down"])
-            
+
             response = client.post(
                 "/api/v1/subtitles/extract",
                 json={"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "lang": "en"},
                 headers={"x-api-key": api_key}
             )
-            
+
             assert response.status_code == 200
             data = response.json()
             assert data["status"] == "success"
             assert data["video_id"] == "dQw4w9WgXcQ"
             assert "Never gonna give you up" in data["subtitles"]
-    
+
     def test_extract_subtitles_endpoint_invalid_api_key(self, client, invalid_api_key):
         """Test API endpoint with invalid API key."""
         response = client.post(
@@ -182,18 +143,18 @@ class TestSubtitleAPI:
             json={"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "lang": "en"},
             headers={"x-api-key": invalid_api_key}
         )
-        
+
         assert response.status_code == 401
-    
+
     def test_extract_subtitles_endpoint_missing_api_key(self, client):
         """Test API endpoint with missing API key."""
         response = client.post(
             "/api/v1/subtitles/extract",
             json={"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "lang": "en"}
         )
-        
+
         assert response.status_code == 401
-    
+
     def test_extract_subtitles_endpoint_invalid_url(self, client, api_key):
         """Test API endpoint with invalid URL."""
         response = client.post(
@@ -201,28 +162,13 @@ class TestSubtitleAPI:
             json={"url": "https://example.com/not-youtube", "lang": "en"},
             headers={"x-api-key": api_key}
         )
-        
-        assert response.status_code == 422  # Validation error
-    
-    def test_extract_subtitles_endpoint_not_found(self, client, api_key):
-        """Test API endpoint when subtitles are not found."""
-        with patch('app.apis.subtitles.service.subtitle_service.extract_subtitles') as mock_extract:
-            mock_extract.side_effect = SubtitlesNotFoundError("No subtitles available")
-            
-            response = client.post(
-                "/api/v1/subtitles/extract",
-                json={"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "lang": "en"},
-                headers={"x-api-key": api_key}
-            )
-            
-            assert response.status_code == 404
-            data = response.json()
-            assert data["detail"]["status"] == "error"
-    
+
+        assert response.status_code == 422
+
     def test_subtitles_health_endpoint(self, client):
         """Test subtitles health check endpoint."""
         response = client.get("/api/v1/subtitles/health")
-        
+
         assert response.status_code == 200
         data = response.json()
         assert data["status"] == "healthy"