docs: update README files for Docker-only API setup

README.md

@@ -1,14 +1,58 @@
 ---
-title: Video Face Swap
+title: Video Face Swap API
 emoji: 👱🏻‍♀️
 colorFrom: pink
 colorTo: indigo
-sdk: gradio
-sdk_version: 5.49.0
-app_file: app.py
+sdk: docker
+sdk_version: latest
+app_file: api_server.py
 pinned: true
 disable_embedding: false
-short_description: Video deep fake
+short_description: GPU-accelerated face swap video processing API
 ---
-facefusion MIT License
+
+# Face Swap Video API
+
+GPU-accelerated FastAPI backend for face swap video processing with MongoDB storage.
+
+## 🚀 Quick Start
+
+### Docker Deployment (Recommended)
+
+```bash
+docker-compose up --build
+```
+
+The API will be available at `http://localhost:8000`
+
+See [API Documentation](api/README.md) for detailed usage and endpoints.
+
+## Features
+
+- ✅ GPU acceleration with CUDA support
+- ✅ Asynchronous face swap processing
+- ✅ MongoDB Atlas integration
+- ✅ RESTful API with Swagger documentation
+- ✅ Result video download URLs
+- ✅ Job status tracking
+
+## API Endpoints
+
+- `POST /api/source-image` - Upload source image
+- `POST /api/target-video` - Upload target video
+- `POST /api/face-swap` - Start face swap processing
+- `GET /api/job/{job_id}` - Get job status
+- `GET /api/result-video/{result_video_id}` - Download result video
+- `GET /docs` - Interactive API documentation
+
+## Requirements
+
+- Docker with NVIDIA GPU support (nvidia-docker2)
+- MongoDB Atlas account (or local MongoDB)
+- CUDA 12.1+ compatible GPU
+
+## License
+
+MIT License - Based on DeepFakeAI/facefusion
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api/README.md

@@ -1,29 +1,80 @@
 # Face Swap Video API
 
-FastAPI backend for face swap video processing with MongoDB storage.
+FastAPI backend for face swap video processing with MongoDB storage and GPU acceleration.
 
 ## Features
 
 - **Source Image Upload**: Upload and store source images in MongoDB
 - **Target Video Upload**: Upload and store target videos in MongoDB  
-- **Face Swap Processing**: Process face swaps asynchronously
-- **Result Video Storage**: Store processed result videos in MongoDB
+- **Face Swap Processing**: Process face swaps asynchronously with GPU acceleration
+- **Result Video Storage**: Store processed result videos with HTTPS download URLs
 - **Job Status Tracking**: Monitor processing jobs with real-time status
 
-## API Endpoints
+## 🚀 Docker Deployment (Recommended)
+
+### Prerequisites
+- Docker with NVIDIA GPU support (nvidia-docker2)
+- NVIDIA GPU with CUDA support
+
+### Quick Start
+
+1. **Build and run with Docker Compose:**
+```bash
+docker-compose up --build
+```
+
+2. **Or build and run with Docker:**
+```bash
+docker build -t face-swap-api .
+docker run --gpus all -p 8000:8000 \
+  -e MONGODB_URL="your_mongodb_url" \
+  face-swap-api
+```
+
+The API will be available at `http://localhost:8000`
+
+## 📡 API Endpoints
+
+### Base URL
+```
+http://localhost:8000  (Local)
+https://your-domain.com/api  (Production)
+```
 
 ### 1. Source Image Upload
 ```
 POST /api/source-image
 Content-Type: multipart/form-data
-Body: image file
+Body: image file (jpg, png, etc.)
+```
+
+**Response:**
+```json
+{
+  "id": "64f7b8c9e1234567890abcde",
+  "filename": "source.jpg",
+  "file_path": "/path/to/file",
+  "uploaded_at": "2024-01-15T10:30:00.000Z",
+  "status": "uploaded"
+}
 ```
 
 ### 2. Target Video Upload
 ```
 POST /api/target-video
 Content-Type: multipart/form-data
-Body: video file
+Body: video file (mp4, mov, etc.)
+```
+
+**Response:**
+```json
+{
+  "id": "64f7b8c9e1234567890abcdf",
+  "filename": "target.mp4",
+  "file_path": "/path/to/file",
+  "uploaded_at": "2024-01-15T10:30:00.000Z",
+  "status": "uploaded"
+}
 ```
 
 ### 3. Start Face Swap Processing
@@ -31,8 +82,17 @@ Body: video file
 POST /api/face-swap
 Content-Type: application/json
 Body: {
-  "source_image_id": "string",
-  "target_video_id": "string"
+  "source_image_id": "SOURCE_IMAGE_ID",
+  "target_video_id": "TARGET_VIDEO_ID"
+}
+```
+
+**Response:**
+```json
+{
+  "job_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "queued",
+  "progress": 0.0
 }
 ```
 
@@ -41,11 +101,25 @@ Body: {
 GET /api/job/{job_id}
 ```
 
-### 5. Get Result Video
+**Response (when completed):**
+```json
+{
+  "job_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "completed",
+  "progress": 100.0,
+  "result_video_id": "64f7b8c9e1234567890abce0",
+  "result_video_url": "https://your-domain.com/api/result-video/64f7b8c9e1234567890abce0",
+  "error": null
+}
+```
+
+### 5. Download Result Video
 ```
 GET /api/result-video/{result_video_id}
 ```
 
+Returns the processed video file directly.
+
 ### 6. List All Items
 ```
 GET /api/source-images
@@ -53,71 +127,112 @@ GET /api/target-videos
 GET /api/result-videos
 ```
 
-## Setup
-
-1. Install dependencies:
-```bash
-pip install -r api/requirements.txt
+### 7. Health Check
 ```
-
-2. Set environment variables (optional - MongoDB Atlas connection is already configured):
-```bash
-export MONGODB_URL="mongodb+srv://itishalogicgo_db_user:HR837xi0B9yh2vZK@cluster0.jeeytpz.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0"
+GET /api/health
+GET /
 ```
 
-3. Start MongoDB server
+## 🐳 Docker Setup
+
+### Dockerfile
+The Dockerfile uses:
+- **Base Image**: `nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04`
+- **GPU Support**: CUDA 12.1 with cuDNN 8
+- **Python**: 3.10
+- **ONNX Runtime**: GPU version for fast inference
+
+### Environment Variables
 
-4. Run the API:
 ```bash
-cd api
-python main.py
+MONGODB_URL=mongodb+srv://...           # MongoDB connection string
+BASE_URL=http://localhost:8000          # Base URL for download links
+CUDA_VISIBLE_DEVICES=0                   # GPU device ID
 ```
 
-The API will be available at `http://localhost:8000`
+### Docker Compose
+
+The `docker-compose.yml` includes:
+- GPU resource allocation
+- Volume mounts for uploads and models
+- Automatic restart on failure
 
-## Usage Example
+## 📝 Usage Examples
 
-1. Upload source image:
+### cURL Examples
+
+1. **Upload source image:**
 ```bash
 curl -X POST "http://localhost:8000/api/source-image" \
   -H "accept: application/json" \
-  -H "Content-Type: multipart/form-data" \
   -F "file=@source.jpg"
 ```
 
-2. Upload target video:
+2. **Upload target video:**
 ```bash
 curl -X POST "http://localhost:8000/api/target-video" \
   -H "accept: application/json" \
-  -H "Content-Type: multipart/form-data" \
   -F "file=@target.mp4"
 ```
 
-3. Start face swap:
+3. **Start face swap:**
 ```bash
 curl -X POST "http://localhost:8000/api/face-swap" \
-  -H "accept: application/json" \
   -H "Content-Type: application/json" \
   -d '{
-    "source_image_id": "image_id_here",
-    "target_video_id": "video_id_here"
+    "source_image_id": "SOURCE_IMAGE_ID",
+    "target_video_id": "TARGET_VIDEO_ID"
   }'
 ```
 
-4. Check job status:
+4. **Check job status:**
 ```bash
-curl -X GET "http://localhost:8000/api/job/job_id_here"
+curl -X GET "http://localhost:8000/api/job/JOB_ID"
 ```
 
-5. Download result:
+5. **Download result video:**
 ```bash
-curl -X GET "http://localhost:8000/api/result-video/result_id_here" \
-  --output result.mp4
+curl -L -o result.mp4 \
+  "http://localhost:8000/api/result-video/RESULT_VIDEO_ID"
 ```
 
-## Database Schema
+### Python Example
+
+```python
+import requests
+
+BASE_URL = "http://localhost:8000"
+
+# 1. Upload source image
+with open("source.jpg", "rb") as f:
+    response = requests.post(f"{BASE_URL}/api/source-image", files={"file": f})
+    source_id = response.json()["id"]
+
+# 2. Upload target video
+with open("target.mp4", "rb") as f:
+    response = requests.post(f"{BASE_URL}/api/target-video", files={"file": f})
+    target_id = response.json()["id"]
+
+# 3. Start face swap
+response = requests.post(
+    f"{BASE_URL}/api/face-swap",
+    json={"source_image_id": source_id, "target_video_id": target_id}
+)
+job_id = response.json()["job_id"]
+
+# 4. Poll for completion
+while True:
+    status = requests.get(f"{BASE_URL}/api/job/{job_id}").json()
+    if status["status"] == "completed":
+        result_url = status["result_video_url"]
+        print(f"Download URL: {result_url}")
+        break
+    time.sleep(5)
+```
 
-### Source Images Collection
+## 🗄️ Database Schema
+
+### Source Images Collection (`source_images`)
 ```json
 {
   "_id": "ObjectId",
@@ -130,7 +245,7 @@ curl -X GET "http://localhost:8000/api/result-video/result_id_here" \
 }
 ```
 
-### Target Videos Collection
+### Target Videos Collection (`target_videos`)
 ```json
 {
   "_id": "ObjectId",
@@ -143,7 +258,7 @@ curl -X GET "http://localhost:8000/api/result-video/result_id_here" \
 }
 ```
 
-### Result Videos Collection
+### Result Videos Collection (`result_videos`)
 ```json
 {
   "_id": "ObjectId",
@@ -157,17 +272,66 @@ curl -X GET "http://localhost:8000/api/result-video/result_id_here" \
 }
 ```
 
-### Processing Jobs Collection
+### Processing Jobs Collection (`processing_jobs`)
 ```json
 {
   "_id": "ObjectId",
-  "job_id": "string",
+  "job_id": "string (UUID)",
   "source_image_id": "string",
   "target_video_id": "string",
-  "status": "string",
+  "status": "string (queued|processing|completed|failed)",
   "created_at": "datetime",
-  "progress": "number",
+  "progress": "number (0-100)",
   "result_video_id": "string",
+  "result_video_url": "string",
   "error": "string"
 }
 ```
+
+## 🔧 Configuration
+
+### MongoDB Connection
+- **Connection String**: Set via `MONGODB_URL` environment variable
+- **Database**: `face_swap_video`
+- **Collections**: `source_images`, `target_videos`, `result_videos`, `processing_jobs`
+
+### GPU Configuration
+- **CUDA Version**: 12.1
+- **cuDNN**: 8
+- **ONNX Runtime**: GPU-enabled
+- **Device**: Automatically detects and uses available GPU
+
+## 📊 API Documentation
+
+Once running, visit:
+- **Swagger UI**: `http://localhost:8000/docs`
+- **ReDoc**: `http://localhost:8000/redoc`
+
+## 🚨 Troubleshooting
+
+### GPU Not Detected
+Check NVIDIA drivers:
+```bash
+nvidia-smi
+```
+
+### MongoDB Connection Issues
+Verify connection string and network access to MongoDB Atlas.
+
+### Model Download Failures
+Ensure `TOKEN` or `HF_TOKEN` environment variable is set for Hugging Face downloads.
+
+## 📦 Files Structure
+
+```
+.
+├── api_server.py          # Main API server (no Gradio)
+├── Dockerfile             # Docker image with GPU support
+├── docker-compose.yml     # Docker Compose configuration
+├── requirements.txt       # Python dependencies
+├── DeepFakeAI/           # Face swap processing library
+└── uploads/               # Uploaded files directory
+    ├── source_images/
+    ├── target_videos/
+    └── result_videos/
+```

api_server.py

@@ -0,0 +1,437 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List
+import os
+import uuid
+import asyncio
+from datetime import datetime
+import motor.motor_asyncio
+from bson import ObjectId
+import json
+import shutil
+from pathlib import Path
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
+
+# Import face swap functionality
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import DeepFakeAI.globals as DF_G
+from DeepFakeAI import utilities as DF_U
+from DeepFakeAI.processors.frame.modules import face_swapper as DF_FS
+
+app = FastAPI(title="Face Swap Video API", version="1.0.0")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# MongoDB connection
+MONGODB_URL = os.getenv("MONGODB_URL", "mongodb+srv://itishalogicgo_db_user:HR837xi0B9yh2vZK@cluster0.jeeytpz.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0")
+DATABASE_NAME = "face_swap_video"
+client = motor.motor_asyncio.AsyncIOMotorClient(MONGODB_URL)
+db = client[DATABASE_NAME]
+
+# Collections
+source_images_collection = db["source_images"]
+target_videos_collection = db["target_videos"]
+result_videos_collection = db["result_videos"]
+jobs_collection = db["processing_jobs"]
+
+# Upload directories
+UPLOAD_DIR = Path("uploads")
+SOURCE_IMAGES_DIR = UPLOAD_DIR / "source_images"
+TARGET_VIDEOS_DIR = UPLOAD_DIR / "target_videos"
+RESULT_VIDEOS_DIR = UPLOAD_DIR / "result_videos"
+
+# Create directories
+for dir_path in [UPLOAD_DIR, SOURCE_IMAGES_DIR, TARGET_VIDEOS_DIR, RESULT_VIDEOS_DIR]:
+    dir_path.mkdir(parents=True, exist_ok=True)
+
+def _run_local_faceswap(source_image_path: str, target_video_path: str) -> Optional[str]:
+    # Configure defaults for local pipeline
+    DF_G.source_path = source_image_path
+    DF_G.target_path = target_video_path
+    DF_G.output_video_encoder = 'libx264'
+    DF_G.output_video_quality = 20
+    DF_G.temp_frame_format = 'png'
+    DF_G.temp_frame_quality = 95
+    DF_G.keep_temp = False
+    DF_G.skip_audio = False
+    # Face processing options
+    DF_G.face_recognition = ['many']
+    DF_G.reference_frame_number = 0
+    DF_G.execution_thread_count = 2
+    DF_G.execution_queue_count = 2
+    # Prefer CUDA (GPU) if available; fallback to CPU
+    try:
+        DF_G.execution_providers = DF_U.decode_execution_providers(['cuda', 'cpu'])
+    except:
+        DF_G.execution_providers = DF_U.decode_execution_providers(['cpu'])
+    # Fix invalid OMP thread settings
+    try:
+        import os as _os
+        _os.environ["OMP_NUM_THREADS"] = "1"
+    except:
+        pass
+
+    # Ensure model exists
+    model_dir = DF_U.resolve_relative_path('../.assets/models')
+    os.makedirs(model_dir, exist_ok=True)
+    model_path = os.path.join(model_dir, 'inswapper_128.onnx')
+    if not os.path.exists(model_path):
+        from huggingface_hub import hf_hub_download
+        token = os.environ.get('TOKEN') or os.environ.get('HF_TOKEN')
+        for repo_id in ['zihaomu/inswapper_128.onnx', 'linyi/inswapper_128.onnx', 'banodoco/inswapper_128.onnx']:
+            try:
+                model_path = hf_hub_download(repo_id=repo_id, filename='inswapper_128.onnx', token=token)
+                break
+            except:
+                continue
+    if os.path.exists(model_path):
+        os.environ['INSWAPPER_PATH'] = model_path
+    DF_FS.pre_check()
+
+    # Extract frames
+    fps = DF_U.detect_fps(target_video_path) or 12.0
+    DF_U.create_temp(target_video_path)
+    ok = DF_U.extract_frames(target_video_path, fps)
+    if not ok:
+        return None
+    temp_frames = DF_U.get_temp_frame_paths(target_video_path)
+    if not temp_frames:
+        return None
+
+    # Process frames
+    DF_FS.process_video(source_image_path, temp_frames)
+
+    # Rebuild video and restore audio
+    if not DF_U.create_video(target_video_path, fps):
+        return None
+    out_path = DF_U.normalize_output_path(source_image_path, target_video_path, str(RESULT_VIDEOS_DIR / f"out_{uuid.uuid4().hex}.mp4"))
+    DF_U.restore_audio(target_video_path, out_path)
+    DF_U.clear_temp(target_video_path)
+    return out_path
+
+# Pydantic models
+class SourceImageResponse(BaseModel):
+    id: str
+    filename: str
+    file_path: str
+    uploaded_at: datetime
+    status: str
+
+class TargetVideoResponse(BaseModel):
+    id: str
+    filename: str
+    file_path: str
+    uploaded_at: datetime
+    status: str
+
+class ResultVideoResponse(BaseModel):
+    id: str
+    source_image_id: str
+    target_video_id: str
+    result_file_path: str
+    created_at: datetime
+    status: str
+    processing_time: Optional[float] = None
+
+class FaceSwapRequest(BaseModel):
+    source_image_id: str
+    target_video_id: str
+
+class JobStatus(BaseModel):
+    job_id: str
+    status: str
+    progress: Optional[float] = None
+    result_video_id: Optional[str] = None
+    result_video_url: Optional[str] = None  # HTTPS download URL
+    error: Optional[str] = None
+
+# Base URL for generating download links
+BASE_URL = os.getenv("BASE_URL", "https://logicgoinfotechspaces-face-swap-video.hf.space")
+
+def get_result_video_url(result_video_id: str) -> str:
+    """Generate HTTPS download URL for result video"""
+    return f"{BASE_URL}/api/result-video/{result_video_id}"
+
+# Helper functions
+def save_file_to_disk(file: UploadFile, directory: Path) -> str:
+    """Save uploaded file to disk and return the file path"""
+    file_extension = Path(file.filename).suffix
+    unique_filename = f"{uuid.uuid4().hex}{file_extension}"
+    file_path = directory / unique_filename
+    
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    return str(file_path)
+
+async def process_face_swap(job_id: str, source_image_path: str, target_video_path: str):
+    """Background task to process face swap"""
+    try:
+        # Update job status to processing
+        await jobs_collection.update_one(
+            {"job_id": job_id},
+            {"$set": {"status": "processing", "progress": 0.0}}
+        )
+        
+        # Run face swap
+        result_path = _run_local_faceswap(source_image_path, target_video_path)
+        
+        if result_path and os.path.exists(result_path):
+            # Save result to MongoDB
+            result_doc = {
+                "source_image_path": source_image_path,
+                "target_video_path": target_video_path,
+                "result_file_path": result_path,
+                "created_at": datetime.utcnow(),
+                "status": "completed",
+                "job_id": job_id
+            }
+            
+            result = await result_videos_collection.insert_one(result_doc)
+            result_video_id = str(result.inserted_id)
+            
+            # Update job status to completed
+            await jobs_collection.update_one(
+                {"job_id": job_id},
+                {"$set": {
+                    "status": "completed", 
+                    "progress": 100.0,
+                    "result_video_id": result_video_id,
+                    "result_video_url": get_result_video_url(result_video_id)
+                }}
+            )
+        else:
+            # Update job status to failed
+            await jobs_collection.update_one(
+                {"job_id": job_id},
+                {"$set": {
+                    "status": "failed", 
+                    "error": "Face swap processing failed"
+                }}
+            )
+            
+    except Exception as e:
+        # Update job status to failed
+        await jobs_collection.update_one(
+            {"job_id": job_id},
+            {"$set": {
+                "status": "failed", 
+                "error": str(e)
+            }}
+        )
+
+# API Endpoints
+
+@app.post("/api/source-image", response_model=SourceImageResponse)
+async def upload_source_image(file: UploadFile = File(...)):
+    """Upload and store source image in MongoDB"""
+    if not file.content_type.startswith('image/'):
+        raise HTTPException(status_code=400, detail="File must be an image")
+    
+    try:
+        # Save file to disk
+        file_path = save_file_to_disk(file, SOURCE_IMAGES_DIR)
+        
+        # Store metadata in MongoDB
+        doc = {
+            "filename": file.filename,
+            "file_path": file_path,
+            "uploaded_at": datetime.utcnow(),
+            "status": "uploaded",
+            "content_type": file.content_type,
+            "file_size": os.path.getsize(file_path)
+        }
+        
+        result = await source_images_collection.insert_one(doc)
+        
+        return SourceImageResponse(
+            id=str(result.inserted_id),
+            filename=file.filename,
+            file_path=file_path,
+            uploaded_at=doc["uploaded_at"],
+            status=doc["status"]
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error uploading source image: {str(e)}")
+
+@app.post("/api/target-video", response_model=TargetVideoResponse)
+async def upload_target_video(file: UploadFile = File(...)):
+    """Upload and store target video in MongoDB"""
+    if not file.content_type.startswith('video/'):
+        raise HTTPException(status_code=400, detail="File must be a video")
+    
+    try:
+        # Save file to disk
+        file_path = save_file_to_disk(file, TARGET_VIDEOS_DIR)
+        
+        # Store metadata in MongoDB
+        doc = {
+            "filename": file.filename,
+            "file_path": file_path,
+            "uploaded_at": datetime.utcnow(),
+            "status": "uploaded",
+            "content_type": file.content_type,
+            "file_size": os.path.getsize(file_path)
+        }
+        
+        result = await target_videos_collection.insert_one(doc)
+        
+        return TargetVideoResponse(
+            id=str(result.inserted_id),
+            filename=file.filename,
+            file_path=file_path,
+            uploaded_at=doc["uploaded_at"],
+            status=doc["status"]
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error uploading target video: {str(e)}")
+
+@app.post("/api/face-swap", response_model=JobStatus)
+async def start_face_swap(request: FaceSwapRequest, background_tasks: BackgroundTasks):
+    """Start face swap processing"""
+    try:
+        # Get source image and target video from MongoDB
+        source_image = await source_images_collection.find_one({"_id": ObjectId(request.source_image_id)})
+        target_video = await target_videos_collection.find_one({"_id": ObjectId(request.target_video_id)})
+        
+        if not source_image:
+            raise HTTPException(status_code=404, detail="Source image not found")
+        if not target_video:
+            raise HTTPException(status_code=404, detail="Target video not found")
+        
+        # Create job record
+        job_id = str(uuid.uuid4())
+        job_doc = {
+            "job_id": job_id,
+            "source_image_id": request.source_image_id,
+            "target_video_id": request.target_video_id,
+            "status": "queued",
+            "created_at": datetime.utcnow(),
+            "progress": 0.0
+        }
+        
+        await jobs_collection.insert_one(job_doc)
+        
+        # Start background processing
+        background_tasks.add_task(
+            process_face_swap,
+            job_id,
+            source_image["file_path"],
+            target_video["file_path"]
+        )
+        
+        return JobStatus(
+            job_id=job_id,
+            status="queued",
+            progress=0.0
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error starting face swap: {str(e)}")
+
+@app.get("/api/job/{job_id}", response_model=JobStatus)
+async def get_job_status(job_id: str):
+    """Get job status"""
+    job = await jobs_collection.find_one({"job_id": job_id})
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    
+    result_video_url = None
+    if job.get("result_video_id"):
+        result_video_url = get_result_video_url(job["result_video_id"])
+    
+    return JobStatus(
+        job_id=job["job_id"],
+        status=job["status"],
+        progress=job.get("progress"),
+        result_video_id=job.get("result_video_id"),
+        result_video_url=result_video_url,
+        error=job.get("error")
+    )
+
+@app.get("/api/result-video/{result_video_id}")
+async def get_result_video(result_video_id: str):
+    """Get result video file"""
+    result = await result_videos_collection.find_one({"_id": ObjectId(result_video_id)})
+    if not result:
+        raise HTTPException(status_code=404, detail="Result video not found")
+    
+    if not os.path.exists(result["result_file_path"]):
+        raise HTTPException(status_code=404, detail="Result video file not found")
+    
+    return FileResponse(
+        path=result["result_file_path"],
+        media_type="video/mp4",
+        filename=f"face_swap_result_{result_video_id}.mp4"
+    )
+
+@app.get("/api/source-images", response_model=List[SourceImageResponse])
+async def list_source_images():
+    """List all source images"""
+    cursor = source_images_collection.find().sort("uploaded_at", -1)
+    images = []
+    async for doc in cursor:
+        images.append(SourceImageResponse(
+            id=str(doc["_id"]),
+            filename=doc["filename"],
+            file_path=doc["file_path"],
+            uploaded_at=doc["uploaded_at"],
+            status=doc["status"]
+        ))
+    return images
+
+@app.get("/api/target-videos", response_model=List[TargetVideoResponse])
+async def list_target_videos():
+    """List all target videos"""
+    cursor = target_videos_collection.find().sort("uploaded_at", -1)
+    videos = []
+    async for doc in cursor:
+        videos.append(TargetVideoResponse(
+            id=str(doc["_id"]),
+            filename=doc["filename"],
+            file_path=doc["file_path"],
+            uploaded_at=doc["uploaded_at"],
+            status=doc["status"]
+        ))
+    return videos
+
+@app.get("/api/result-videos", response_model=List[ResultVideoResponse])
+async def list_result_videos():
+    """List all result videos"""
+    cursor = result_videos_collection.find().sort("created_at", -1)
+    results = []
+    async for doc in cursor:
+        results.append(ResultVideoResponse(
+            id=str(doc["_id"]),
+            source_image_id=doc.get("source_image_path", ""),
+            target_video_id=doc.get("target_video_path", ""),
+            result_file_path=doc["result_file_path"],
+            created_at=doc["created_at"],
+            status=doc["status"],
+            processing_time=doc.get("processing_time")
+        ))
+    return results
+
+@app.get("/api/health")
+async def api_health():
+    return {"status": "ok", "time": datetime.utcnow().isoformat()}
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {"message": "Face Swap Video API is running", "version": "1.0.0"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)