Upload 6 files

.env.example

@@ -0,0 +1 @@
+BABELDOCS_MODAL_URL=https://your-workspace.modal.run

__init__.py

@@ -0,0 +1 @@
+# A simple MCP server for document translation with layout preservation

app.py

@@ -0,0 +1,319 @@
+"""
+BabelDocs x Agentic AI MCP - Gradio Application
+
+PDF Translation with Google Drive Integration.
+Accepts public GDrive links or local file uploads.
+
+For Anthropic Hackathon - Track 1: Building MCP
+
+Usage:
+    python app.py
+"""
+
+import os
+import re
+import base64
+import tempfile
+import httpx
+import gradio as gr
+from pathlib import Path
+from datetime import datetime
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Modal endpoint configuration
+# Set BABELDOCS_MODAL_URL as HuggingFace Space secret for production
+MODAL_BASE_URL = os.getenv("BABELDOCS_MODAL_URL")
+if not MODAL_BASE_URL:
+    raise ValueError("BABELDOCS_MODAL_URL environment variable required. Set it as a HuggingFace Space secret.")
+MODAL_TRANSLATE_URL = f"{MODAL_BASE_URL}-babeldocstranslator-api.modal.run"
+MODAL_HEALTH_URL = f"{MODAL_BASE_URL}-babeldocstranslator-health.modal.run"
+
+# Max pages limit (test phase)
+MAX_PAGES = 20
+
+# Supported languages
+LANGUAGES = {
+    "fr": "French",
+    "en": "English",
+    "es": "Spanish",
+    "de": "German",
+    "it": "Italian",
+    "pt": "Portuguese",
+    "zh": "Chinese",
+    "ja": "Japanese",
+    "ko": "Korean",
+    "ru": "Russian",
+    "ar": "Arabic",
+}
+
+
+def log_message(logs: list, message: str) -> list:
+    """Add timestamped message to logs."""
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    logs.append(f"[{timestamp}] {message}")
+    return logs
+
+
+def extract_gdrive_file_id(url: str) -> str | None:
+    """Extract file ID from Google Drive URL."""
+    patterns = [
+        r"/file/d/([a-zA-Z0-9_-]+)",
+        r"id=([a-zA-Z0-9_-]+)",
+        r"/d/([a-zA-Z0-9_-]+)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, url)
+        if match:
+            return match.group(1)
+    return None
+
+
+async def download_gdrive_public(url: str) -> tuple[bytes, str]:
+    """Download file from public Google Drive link.
+
+    Returns (file_bytes, filename).
+    """
+    file_id = extract_gdrive_file_id(url)
+    if not file_id:
+        raise ValueError("Invalid Google Drive URL")
+
+    # Direct download URL
+    download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+
+    async with httpx.AsyncClient(timeout=120.0, follow_redirects=True) as client:
+        response = await client.get(download_url)
+        response.raise_for_status()
+
+        # Try to get filename from Content-Disposition header
+        content_disp = response.headers.get("Content-Disposition", "")
+        filename_match = re.search(r'filename="?([^";\n]+)"?', content_disp)
+        if filename_match:
+            filename = filename_match.group(1)
+        else:
+            filename = f"gdrive_{file_id}.pdf"
+
+        return response.content, filename
+
+
+async def translate_pdf_modal(
+    pdf_file,
+    gdrive_url: str,
+    target_lang: str,
+    progress=gr.Progress()
+) -> tuple:
+    """Translate PDF using Modal cloud."""
+    logs = []
+
+    # Validate input
+    if not pdf_file and not gdrive_url:
+        return None, None, "Please upload a PDF or provide a Google Drive link", "", "\n".join(logs)
+
+    if pdf_file and gdrive_url:
+        return None, None, "Please use either file upload OR Google Drive link, not both", "", "\n".join(logs)
+
+    try:
+        logs = log_message(logs, "Starting translation...")
+
+        # Get PDF bytes and filename
+        if gdrive_url:
+            logs = log_message(logs, f"Downloading from Google Drive...")
+            progress(0.05, desc="Downloading from Google Drive...")
+            pdf_bytes, source_filename = await download_gdrive_public(gdrive_url.strip())
+            logs = log_message(logs, f"Downloaded: {source_filename}")
+        else:
+            pdf_path = Path(pdf_file)
+            pdf_bytes = pdf_path.read_bytes()
+            source_filename = pdf_path.name
+
+        pdf_base64 = base64.b64encode(pdf_bytes).decode("utf-8")
+
+        logs = log_message(logs, f"Input: {source_filename}")
+        logs = log_message(logs, f"Size: {len(pdf_bytes) / 1024:.1f} KB")
+        logs = log_message(logs, f"Target: {LANGUAGES.get(target_lang, target_lang)}")
+
+        progress(0.1, desc="Uploading to Modal...")
+
+        payload = {
+            "pdf_base64": pdf_base64,
+            "target_lang": target_lang,
+        }
+
+        logs = log_message(logs, "Translating on Modal cloud...")
+        logs = log_message(logs, "(This may take several minutes)")
+
+        progress(0.2, desc="Translating...")
+        start_time = datetime.now()
+
+        async with httpx.AsyncClient(timeout=900.0, follow_redirects=True) as client:
+            response = await client.post(MODAL_TRANSLATE_URL, json=payload)
+            response.raise_for_status()
+            result = response.json()
+
+        duration = (datetime.now() - start_time).total_seconds()
+        progress(0.8, desc="Processing result...")
+
+        if not result.get("success"):
+            error_msg = result.get("message", "Unknown error")
+            logs = log_message(logs, f"ERROR: {error_msg}")
+            return None, None, "Translation failed", "", "\n".join(logs)
+
+        # Process mono_img PDF
+        mono_img_path = None
+        mono_img_base64 = result.get("mono_img_pdf_base64")
+        if mono_img_base64:
+            mono_img_bytes = base64.b64decode(mono_img_base64)
+            stem = Path(source_filename).stem
+            mono_img_filename = f"{stem}_translated.{target_lang}.pdf"
+            mono_img_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+            mono_img_file.write(mono_img_bytes)
+            mono_img_file.close()
+            mono_img_path = mono_img_file.name
+            logs = log_message(logs, f"Mono: {mono_img_filename} ({len(mono_img_bytes) / 1024:.1f} KB)")
+
+        # Process dual_img PDF
+        dual_img_path = None
+        dual_img_base64 = result.get("dual_img_pdf_base64")
+        if dual_img_base64:
+            dual_img_bytes = base64.b64decode(dual_img_base64)
+            stem = Path(source_filename).stem
+            dual_img_filename = f"{stem}_translated.{target_lang}.dual.pdf"
+            dual_img_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+            dual_img_file.write(dual_img_bytes)
+            dual_img_file.close()
+            dual_img_path = dual_img_file.name
+            logs = log_message(logs, f"Dual: {dual_img_filename} ({len(dual_img_bytes) / 1024:.1f} KB)")
+
+        if not mono_img_path and not dual_img_path:
+            logs = log_message(logs, "ERROR: No output PDF in response")
+            return None, None, "Translation failed", "", "\n".join(logs)
+
+        logs = log_message(logs, f"Duration: {duration:.1f} seconds")
+
+        stats_msg = f"""**Translation completed!**
+
+- **Duration:** {duration:.1f} seconds
+- **Target:** {LANGUAGES.get(target_lang, target_lang)}"""
+
+        progress(1.0, desc="Done!")
+
+        return mono_img_path, dual_img_path, "Translation successful!", stats_msg, "\n".join(logs)
+
+    except httpx.TimeoutException:
+        logs = log_message(logs, "ERROR: Translation timed out")
+        return None, None, "Translation timed out", "", "\n".join(logs)
+    except httpx.HTTPStatusError as e:
+        logs = log_message(logs, f"ERROR: HTTP {e.response.status_code}")
+        return None, None, f"HTTP error: {e.response.status_code}", "", "\n".join(logs)
+    except Exception as e:
+        logs = log_message(logs, f"ERROR: {str(e)}")
+        return None, None, f"Error: {str(e)}", "", "\n".join(logs)
+
+
+# Gradio Interface
+with gr.Blocks(title="BabelDocs x Agentic AI MCP") as demo:
+
+    gr.Markdown("""
+# BabelDocs x Agentic AI MCP - PDF Translation with Google Drive Integration
+
+**Translate PDFs directly from Google Drive and save back automatically**
+
+---
+
+## Key Feature: Full Google Drive Workflow in CLAUDE Desktop MCP
+
+```
+"Translate my Q3 report to French and save it to Translations folder"
+                              ↓
+        Claude searches → downloads → translates → uploads → done!
+```
+
+---
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Input")
+
+            gdrive_url = gr.Textbox(
+                label="Google Drive Link (public)",
+                placeholder="https://drive.google.com/file/d/... or leave empty",
+                info="Paste a public GDrive link, OR upload a local file below",
+            )
+
+            gr.Markdown("**OR**")
+
+            pdf_input = gr.File(
+                label="Upload PDF",
+                file_types=[".pdf"],
+                type="filepath",
+            )
+
+            target_lang = gr.Dropdown(
+                choices=list(LANGUAGES.keys()),
+                value="fr",
+                label="Target Language",
+            )
+
+            translate_btn = gr.Button(
+                "Translate PDF",
+                variant="primary",
+                size="lg",
+            )
+
+        with gr.Column(scale=1):
+            gr.Markdown("### Result")
+
+            status_output = gr.Textbox(
+                label="Status",
+                interactive=False,
+            )
+
+            stats_output = gr.Markdown(label="Statistics")
+
+            gr.Markdown("**Downloads:**")
+            with gr.Row():
+                mono_img_output = gr.File(label="Mono (translated + images)")
+                dual_img_output = gr.File(label="Dual (bilingual + images)")
+
+            logs_output = gr.Textbox(
+                label="Logs",
+                interactive=False,
+                lines=10,
+                max_lines=15,
+            )
+
+    gr.Markdown("""
+---
+
+### How it works
+
+```
+1. Upload PDF or paste GDrive link
+       ↓
+2. Send to Modal cloud (serverless)
+       ↓
+3. BabelDOC with Agentic AI translates text + images, preserves layout
+       ↓
+4. Download translated PDF
+```
+
+---
+
+**Built with:** BabelDOC, Modal, Nebius AI, Gradio | **Hackathon:** Anthropic MCP Track 1
+    """)
+
+    translate_btn.click(
+        fn=translate_pdf_modal,
+        inputs=[pdf_input, gdrive_url, target_lang],
+        outputs=[mono_img_output, dual_img_output, status_output, stats_output, logs_output],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        share=False,
+    )

modal_deploy.py

@@ -0,0 +1,316 @@
+"""
+BabelDOC with Agentic AI - Modal Deployment
+
+PDF translation API with layout preservation.
+20-page limit during test phase.
+
+Setup:
+    modal secret create babeldocs-secrets \
+      NEBIUS_API_KEY=your_key \
+      NEBIUS_API_BASE=https://api.tokenfactory.nebius.com/v1/ \
+      NEBIUS_TRANSLATION_MODEL=openai/gpt-oss-120b
+
+Deploy:
+    modal deploy modal_deploy.py
+"""
+
+import modal
+import os
+from pathlib import Path
+
+THIS_DIR = Path(__file__).parent.resolve()
+BABELDOC_DIR = THIS_DIR.parent / "BabelDOC"
+
+# Max pages allowed (test phase limit)
+MAX_PAGES = 20
+
+# Modal app - custom name for hackathon
+app = modal.App("mcp1stann-babeldocs")
+
+# Image with uv and BabelDOC installed
+babeldocs_image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .apt_install(
+        "git",
+        "libgl1-mesa-glx",
+        "libglib2.0-0",
+        "libsm6",
+        "libxext6",
+        "libxrender-dev",
+        "libgomp1",
+        "curl",
+        "libspatialindex-dev",  # For rtree
+        "libharfbuzz-dev",  # For uharfbuzz
+        "libfreetype6-dev",  # For freetype-py
+        "libopencv-dev",  # For opencv dependencies
+        "libzstd-dev",  # For pyzstd
+    )
+    .pip_install("uv")
+    .env({
+        "PYTHONIOENCODING": "utf-8",
+        "PYTHONUNBUFFERED": "1",
+        "UV_SYSTEM_PYTHON": "1",
+    })
+    .pip_install("fastapi[standard]")
+    .add_local_dir(
+        str(BABELDOC_DIR),
+        remote_path="/app/BabelDOC",
+        copy=True,
+    )
+    .run_commands(
+        "cd /app/BabelDOC && uv pip install -e . --python python3.11",
+    )
+)
+
+# Volume for caching models and fonts
+cache_volume = modal.Volume.from_name("babeldocs-cache", create_if_missing=True)
+CACHE_PATH = "/cache"
+
+
+@app.cls(
+    image=babeldocs_image,
+    timeout=900,  # 15 minutes
+    memory=8192,
+    cpu=4,
+    volumes={CACHE_PATH: cache_volume},
+    secrets=[modal.Secret.from_name("babeldocs-secrets")],
+    scaledown_window=300,  # Keep warm for 5 minutes
+)
+class BabelDocsTranslator:
+    """Class-based translator for BabelDOC (based on working SVG generator pattern)."""
+
+    def _count_pdf_pages(self, pdf_bytes: bytes) -> int:
+        """Count pages in PDF using PyMuPDF."""
+        try:
+            import fitz  # PyMuPDF
+            doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+            count = len(doc)
+            doc.close()
+            return count
+        except Exception:
+            return -1  # Unknown
+
+    def _translate_internal(
+        self,
+        pdf_base64: str,
+        target_lang: str = "fr",
+        pages: str = "",
+        no_dual: bool = False,
+        no_mono: bool = False,
+    ) -> dict:
+        """BabelDOC with Agentic AI - Internal translation."""
+        import base64
+        import subprocess
+        import tempfile
+        from pathlib import Path
+        from datetime import datetime
+
+        try:
+            if not pdf_base64:
+                return {"success": False, "message": "No PDF provided"}
+
+            pdf_bytes = base64.b64decode(pdf_base64)
+
+            # Check page limit (test phase)
+            page_count = self._count_pdf_pages(pdf_bytes)
+            if page_count > MAX_PAGES:
+                return {
+                    "success": False,
+                    "message": f"PDF has {page_count} pages. Maximum allowed: {MAX_PAGES} pages (test phase limit)."
+                }
+
+            with tempfile.TemporaryDirectory() as tmpdir:
+                input_path = Path(tmpdir) / "input.pdf"
+                output_dir = Path(tmpdir) / "output"
+                output_dir.mkdir()
+
+                input_path.write_bytes(pdf_bytes)
+
+                cmd = [
+                    "babeldoc",
+                    "--files", str(input_path),
+                    "--output", str(output_dir),
+                    "--lang-out", target_lang,
+                    "--openai",
+                    "--openai-model", os.getenv("NEBIUS_TRANSLATION_MODEL", "openai/gpt-oss-120b"),
+                    "--openai-base-url", os.getenv("NEBIUS_API_BASE", "https://api.tokenfactory.nebius.com/v1/"),
+                    "--openai-api-key", os.getenv("NEBIUS_API_KEY", ""),
+                    "--no-watermark",
+                    "--translate-table-text",
+                    "--enhance-compatibility",
+                    # Enable image translation (orchestration PASS 2) with vision model
+                    "--vision-model", os.getenv("NEBIUS_VISION_MODEL", "Qwen/Qwen2.5-VL-72B-Instruct"),
+                ]
+
+                if pages:
+                    cmd.extend(["--pages", pages])
+                    cmd.append("--only-include-translated-page")
+
+                if no_dual:
+                    cmd.append("--no-dual")
+
+                if no_mono:
+                    cmd.append("--no-mono")
+
+                start_time = datetime.now()
+
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    cwd="/app/BabelDOC",
+                    env={
+                        **os.environ,
+                        "HF_HOME": CACHE_PATH,
+                    },
+                )
+
+                duration = (datetime.now() - start_time).total_seconds()
+
+                if result.returncode != 0:
+                    return {
+                        "success": False,
+                        "message": "Translation failed",
+                        "stderr": result.stderr[:1000] if result.stderr else "",
+                        "stdout": result.stdout[:500] if result.stdout else "",
+                    }
+
+                # Find all 4 types of PDFs:
+                # Format: name.no_watermark.{lang}.{mono|dual}.pdf
+                # Format: name.no_watermark.{lang}.{mono|dual}.images_translated.pdf
+
+                # Get all PDFs in output directory
+                all_pdfs = list(output_dir.glob("*.pdf"))
+
+                # Categorize by type
+                mono_matches = [p for p in all_pdfs if f".{target_lang}.mono.pdf" in p.name and "images_translated" not in p.name]
+                mono_img_matches = [p for p in all_pdfs if f".{target_lang}.mono.images_translated.pdf" in p.name]
+                dual_matches = [p for p in all_pdfs if f".{target_lang}.dual.pdf" in p.name and "images_translated" not in p.name]
+                dual_img_matches = [p for p in all_pdfs if f".{target_lang}.dual.images_translated.pdf" in p.name]
+
+                mono_pdf = mono_matches[0] if mono_matches else None
+                mono_img_pdf = mono_img_matches[0] if mono_img_matches else None
+                dual_pdf = dual_matches[0] if dual_matches else None
+                dual_img_pdf = dual_img_matches[0] if dual_img_matches else None
+
+                if not any([mono_pdf, mono_img_pdf, dual_pdf, dual_img_pdf]):
+                    # Fallback to any PDF
+                    if not all_pdfs:
+                        return {"success": False, "message": "No output PDF generated"}
+                    mono_pdf = all_pdfs[0]
+
+                result_data = {
+                    "success": True,
+                    "stats": {
+                        "duration_seconds": round(duration, 2),
+                    }
+                }
+
+                # Add mono PDF (without image translation)
+                if mono_pdf and not no_mono:
+                    mono_bytes = mono_pdf.read_bytes()
+                    result_data["mono_pdf_base64"] = base64.b64encode(mono_bytes).decode("utf-8")
+                    result_data["mono_filename"] = mono_pdf.name
+                    result_data["stats"]["mono_size_bytes"] = len(mono_bytes)
+
+                # Add mono PDF with image translation
+                if mono_img_pdf and not no_mono:
+                    mono_img_bytes = mono_img_pdf.read_bytes()
+                    result_data["mono_img_pdf_base64"] = base64.b64encode(mono_img_bytes).decode("utf-8")
+                    result_data["mono_img_filename"] = mono_img_pdf.name
+                    result_data["stats"]["mono_img_size_bytes"] = len(mono_img_bytes)
+
+                # Add dual PDF (without image translation)
+                if dual_pdf and not no_dual:
+                    dual_bytes = dual_pdf.read_bytes()
+                    result_data["dual_pdf_base64"] = base64.b64encode(dual_bytes).decode("utf-8")
+                    result_data["dual_filename"] = dual_pdf.name
+                    result_data["stats"]["dual_size_bytes"] = len(dual_bytes)
+
+                # Add dual PDF with image translation
+                if dual_img_pdf and not no_dual:
+                    dual_img_bytes = dual_img_pdf.read_bytes()
+                    result_data["dual_img_pdf_base64"] = base64.b64encode(dual_img_bytes).decode("utf-8")
+                    result_data["dual_img_filename"] = dual_img_pdf.name
+                    result_data["stats"]["dual_img_size_bytes"] = len(dual_img_bytes)
+
+                return result_data
+
+        except Exception as e:
+            return {"success": False, "message": f"Error: {str(e)}"}
+
+    @modal.method()
+    def translate(
+        self,
+        pdf_base64: str,
+        target_lang: str = "fr",
+        pages: str = "",
+        no_dual: bool = False,
+        no_mono: bool = False,
+    ) -> dict:
+        """Translate method (callable via Modal)."""
+        return self._translate_internal(pdf_base64, target_lang, pages, no_dual, no_mono)
+
+    @modal.fastapi_endpoint(method="POST")
+    def api(self, request: dict) -> dict:
+        """
+        FastAPI endpoint POST for PDF translation.
+
+        Request body:
+        {
+            "pdf_base64": "base64_encoded_pdf",
+            "target_lang": "fr",
+            "pages": "1,2,3" (optional),
+            "no_dual": false,
+            "no_mono": false
+        }
+        """
+        pdf_base64 = request.get("pdf_base64", "")
+        target_lang = request.get("target_lang", "fr")
+        pages = request.get("pages", "")
+        no_dual = request.get("no_dual", False)
+        no_mono = request.get("no_mono", False)
+
+        return self._translate_internal(pdf_base64, target_lang, pages, no_dual, no_mono)
+
+    @modal.fastapi_endpoint(method="GET")
+    def health(self) -> dict:
+        """Health check endpoint."""
+        return {
+            "status": "healthy",
+            "service": "BabelDOC with Agentic AI",
+            "version": "1.0.0",
+            "max_pages": MAX_PAGES,
+        }
+
+    @modal.fastapi_endpoint(method="GET")
+    def languages(self) -> dict:
+        """Get supported languages."""
+        return {
+            "languages": {
+                "fr": "French",
+                "en": "English",
+                "es": "Spanish",
+                "de": "German",
+                "it": "Italian",
+                "pt": "Portuguese",
+                "zh": "Chinese",
+                "ja": "Japanese",
+                "ko": "Korean",
+                "ru": "Russian",
+                "ar": "Arabic",
+            }
+        }
+
+
+@app.local_entrypoint()
+def main():
+    """BabelDOC with Agentic AI - Local test."""
+    print("BabelDOC with Agentic AI - Modal Deployment")
+    print("=" * 45)
+    print(f"Max pages: {MAX_PAGES} (test phase)")
+    print()
+    print("Deploy: modal deploy modal_deploy.py")
+    print("Test:   modal serve modal_deploy.py")

requirements.txt

@@ -0,0 +1,24 @@
+# BabelDocs MCP Server Dependencies
+
+# MCP Framework
+fastmcp>=0.1.0
+
+# Web Framework
+gradio>=4.44.0
+uvicorn>=0.30.0
+
+# PDF Processing
+pymupdf>=1.24.0
+
+# HTTP Client
+httpx>=0.25.0
+
+# Environment
+python-dotenv>=1.0.0
+
+# AI APIs
+anthropic>=0.39.0
+openai>=1.0.0
+
+# Modal deployment
+modal>=0.64.0

server.py

@@ -0,0 +1,511 @@
+"""
+BabelDOC with Agentic AI - MCP Server
+PDF Translation with Layout Preservation + Google Drive Integration
+"""
+
+import os
+import re
+import json
+import base64
+import httpx
+from pathlib import Path
+from typing import Optional, Tuple, List
+from datetime import datetime
+
+from fastmcp import FastMCP
+
+# Google Drive OAuth
+try:
+    from google.oauth2.credentials import Credentials
+    from google_auth_oauthlib.flow import InstalledAppFlow
+    from google.auth.transport.requests import Request
+    from googleapiclient.discovery import build
+    from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
+    import io
+    GOOGLE_AVAILABLE = True
+except ImportError:
+    GOOGLE_AVAILABLE = False
+
+# Constants
+MAX_PAGES = 20  # Test phase limit
+GRADIO_URL = "http://127.0.0.1:7860"
+OUTPUT_DIR = Path.home() / "Downloads" / "BabelDocs"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Google Drive OAuth config
+GDRIVE_SCOPES = ['https://www.googleapis.com/auth/drive']
+GDRIVE_OAUTH_PATH = Path(os.getenv(
+    "GDRIVE_OAUTH_CREDENTIALS",
+    Path.home() / "Downloads" / "gcp-oauth.keys.json"
+))
+GDRIVE_TOKEN_PATH = OUTPUT_DIR / "gdrive_token.json"
+
+# Modal endpoints (set BABELDOCS_MODAL_URL env var)
+MODAL_BASE_URL = os.getenv("BABELDOCS_MODAL_URL")
+if not MODAL_BASE_URL:
+    raise ValueError("BABELDOCS_MODAL_URL environment variable is required")
+MODAL_TRANSLATE_URL = f"{MODAL_BASE_URL}-babeldocstranslator-api.modal.run"
+MODAL_HEALTH_URL = f"{MODAL_BASE_URL}-babeldocstranslator-health.modal.run"
+
+SUPPORTED_LANGUAGES = {
+    "en": "English", "fr": "French", "es": "Spanish", "de": "German",
+    "it": "Italian", "pt": "Portuguese", "zh": "Chinese", "ja": "Japanese",
+    "ko": "Korean", "ru": "Russian", "ar": "Arabic",
+}
+
+
+# === Helper Functions ===
+
+async def _warmup_modal():
+    """Wake up Modal container."""
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            await client.get(MODAL_HEALTH_URL)
+    except:
+        pass
+
+
+def _count_pdf_pages(pdf_bytes: bytes) -> int:
+    """Count pages in PDF."""
+    try:
+        import fitz
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        count = len(doc)
+        doc.close()
+        return count
+    except ImportError:
+        content = pdf_bytes.decode('latin-1', errors='ignore')
+        return content.count('/Type /Page') - content.count('/Type /Pages')
+
+
+def _extract_gdrive_file_id(url: str) -> Optional[str]:
+    """Extract file ID from Google Drive URL."""
+    patterns = [
+        r'/file/d/([a-zA-Z0-9_-]+)',
+        r'id=([a-zA-Z0-9_-]+)',
+        r'/open\?id=([a-zA-Z0-9_-]+)',
+        r'^([a-zA-Z0-9_-]{25,})$',
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, url)
+        if match:
+            return match.group(1)
+    return None
+
+
+def _get_gdrive_credentials():
+    """Get or refresh Google Drive credentials."""
+    if not GOOGLE_AVAILABLE:
+        return None, "Google libraries not installed"
+    if not GDRIVE_OAUTH_PATH.exists():
+        return None, f"OAuth credentials not found at {GDRIVE_OAUTH_PATH}"
+
+    creds = None
+    if GDRIVE_TOKEN_PATH.exists():
+        try:
+            creds = Credentials.from_authorized_user_file(str(GDRIVE_TOKEN_PATH), GDRIVE_SCOPES)
+        except:
+            pass
+
+    if not creds or not creds.valid:
+        if creds and creds.expired and creds.refresh_token:
+            try:
+                creds.refresh(Request())
+            except:
+                creds = None
+
+        if not creds:
+            try:
+                flow = InstalledAppFlow.from_client_secrets_file(str(GDRIVE_OAUTH_PATH), GDRIVE_SCOPES)
+                for port in [8101, 8102, 8103, 0]:
+                    try:
+                        creds = flow.run_local_server(port=port, open_browser=True, bind_addr="127.0.0.1")
+                        break
+                    except OSError:
+                        if port == 0:
+                            raise
+            except Exception as e:
+                return None, f"OAuth failed: {str(e)}"
+
+        with open(GDRIVE_TOKEN_PATH, 'w') as token:
+            token.write(creds.to_json())
+
+    return creds, None
+
+
+def _upload_to_gdrive(file_path: str, folder_id: Optional[str] = None) -> Tuple[Optional[str], Optional[str]]:
+    """Upload file to Google Drive. Returns (file_id, error)."""
+    creds, error = _get_gdrive_credentials()
+    if error:
+        return None, error
+
+    try:
+        service = build('drive', 'v3', credentials=creds)
+        file_metadata = {'name': Path(file_path).name}
+        if folder_id:
+            file_metadata['parents'] = [folder_id]
+
+        media = MediaFileUpload(file_path, mimetype='application/pdf', resumable=True)
+        file = service.files().create(body=file_metadata, media_body=media, fields='id, webViewLink').execute()
+        return file.get('id'), None
+    except Exception as e:
+        return None, f"Upload failed: {str(e)}"
+
+
+def _list_gdrive_folders() -> Tuple[Optional[List[dict]], Optional[str]]:
+    """List folders in Google Drive."""
+    creds, error = _get_gdrive_credentials()
+    if error:
+        return None, error
+
+    try:
+        service = build('drive', 'v3', credentials=creds)
+        results = service.files().list(
+            q="mimeType='application/vnd.google-apps.folder' and trashed=false",
+            fields='files(id, name)', pageSize=50
+        ).execute()
+        return results.get('files', []), None
+    except Exception as e:
+        return None, f"Failed to list folders: {str(e)}"
+
+
+def _list_gdrive_files(folder_id: Optional[str] = None, file_type: Optional[str] = None) -> Tuple[Optional[List[dict]], Optional[str]]:
+    """List files in Google Drive."""
+    creds, error = _get_gdrive_credentials()
+    if error:
+        return None, error
+
+    try:
+        service = build('drive', 'v3', credentials=creds)
+        query_parts = ["trashed=false"]
+        if folder_id:
+            query_parts.append(f"'{folder_id}' in parents")
+        if file_type == "pdf":
+            query_parts.append("mimeType='application/pdf'")
+        elif file_type == "folder":
+            query_parts.append("mimeType='application/vnd.google-apps.folder'")
+
+        results = service.files().list(
+            q=" and ".join(query_parts),
+            fields='files(id, name, mimeType, size, webViewLink)',
+            pageSize=100, orderBy='modifiedTime desc'
+        ).execute()
+        return results.get('files', []), None
+    except Exception as e:
+        return None, f"Failed to list files: {str(e)}"
+
+
+def _search_gdrive_files(query: str, file_type: Optional[str] = None) -> Tuple[Optional[List[dict]], Optional[str]]:
+    """Search files in Google Drive by name."""
+    creds, error = _get_gdrive_credentials()
+    if error:
+        return None, error
+
+    try:
+        service = build('drive', 'v3', credentials=creds)
+        query_parts = [f"name contains '{query}'", "trashed=false"]
+        if file_type == "pdf":
+            query_parts.append("mimeType='application/pdf'")
+
+        results = service.files().list(
+            q=" and ".join(query_parts),
+            fields='files(id, name, mimeType, size, webViewLink)',
+            pageSize=50, orderBy='modifiedTime desc'
+        ).execute()
+        return results.get('files', []), None
+    except Exception as e:
+        return None, f"Search failed: {str(e)}"
+
+
+def _download_gdrive_file(file_id: str, destination: Optional[str] = None) -> Tuple[Optional[str], Optional[str]]:
+    """Download file from Google Drive."""
+    creds, error = _get_gdrive_credentials()
+    if error:
+        return None, error
+
+    try:
+        service = build('drive', 'v3', credentials=creds)
+        file_metadata = service.files().get(fileId=file_id, fields='name').execute()
+        filename = file_metadata.get('name', f'download_{file_id}')
+
+        dest_path = Path(destination) / filename if destination else OUTPUT_DIR / filename
+
+        request = service.files().get_media(fileId=file_id)
+        file_handle = io.BytesIO()
+        downloader = MediaIoBaseDownload(file_handle, request)
+        done = False
+        while not done:
+            _, done = downloader.next_chunk()
+
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+        dest_path.write_bytes(file_handle.getvalue())
+        return str(dest_path), None
+    except Exception as e:
+        return None, f"Download failed: {str(e)}"
+
+
+async def _get_pdf_bytes(source: str) -> Tuple[bytes, str, Optional[str]]:
+    """Get PDF bytes from local file or Google Drive URL. Returns (bytes, source_name, error)."""
+    # Google Drive URL
+    if "drive.google.com" in source or "docs.google.com" in source:
+        file_id = _extract_gdrive_file_id(source)
+        if not file_id:
+            return b"", "", "Invalid Google Drive URL"
+
+        local_path, error = _download_gdrive_file(file_id)
+        if error:
+            return b"", "", error
+
+        pdf_bytes = Path(local_path).read_bytes()
+        return pdf_bytes, f"Google Drive: {Path(local_path).name}", None
+
+    # Just file ID
+    if re.match(r'^[a-zA-Z0-9_-]{25,}$', source):
+        local_path, error = _download_gdrive_file(source)
+        if error:
+            return b"", "", error
+
+        pdf_bytes = Path(local_path).read_bytes()
+        return pdf_bytes, f"Google Drive: {Path(local_path).name}", None
+
+    # Local file
+    pdf_path = Path(source)
+    if not pdf_path.exists():
+        return b"", "", f"File not found: {source}"
+    if pdf_path.suffix.lower() != ".pdf":
+        return b"", "", "File must be a PDF"
+
+    return pdf_path.read_bytes(), pdf_path.name, None
+
+
+# === MCP Server ===
+
+mcp = FastMCP(
+    name="babeldocs",
+    instructions=f"""PDF translation with layout preservation + Google Drive integration.
+
+Max {MAX_PAGES} pages. For larger PDFs use Gradio at {GRADIO_URL}
+
+WORKFLOW:
+1. search_gdrive("filename") - Find PDF
+2. download_from_gdrive(file_id) - Download
+3. translate_pdf(path, "fr") - Translate
+4. upload_to_gdrive(path, folder_id) - Upload
+
+Or all-in-one: translate_and_upload(source, "fr", folder_id)
+
+Output: {OUTPUT_DIR}
+"""
+)
+
+
+@mcp.tool()
+async def translate_pdf(source: str, target_lang: str = "fr") -> dict:
+    """Translate PDF with layout preservation. Returns single translated file."""
+    await _warmup_modal()
+
+    try:
+        pdf_bytes, source_name, error = await _get_pdf_bytes(source)
+        if error:
+            return {"success": False, "message": error}
+
+        page_count = _count_pdf_pages(pdf_bytes)
+        if page_count > MAX_PAGES:
+            return {
+                "success": False,
+                "message": f"PDF has {page_count} pages (max {MAX_PAGES}). Use Gradio: {GRADIO_URL}"
+            }
+
+        if target_lang not in SUPPORTED_LANGUAGES:
+            return {"success": False, "message": f"Unsupported language: {target_lang}"}
+
+        # Call Modal
+        payload = {
+            "pdf_base64": base64.b64encode(pdf_bytes).decode("utf-8"),
+            "target_lang": target_lang,
+            "no_dual": True,
+            "no_mono": False,
+        }
+
+        async with httpx.AsyncClient(timeout=900.0, follow_redirects=True) as client:
+            response = await client.post(MODAL_TRANSLATE_URL, json=payload)
+            response.raise_for_status()
+            result = response.json()
+
+        if not result.get("success"):
+            return {"success": False, "message": result.get("message", "Translation failed")}
+
+        # Get mono_img (priority) or mono
+        pdf_data = result.get("mono_img_pdf_base64") or result.get("mono_pdf_base64")
+        if not pdf_data:
+            return {"success": False, "message": "No output PDF generated"}
+
+        # Build output filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        if source_name.startswith("Google Drive:"):
+            output_filename = f"translated_{timestamp}.{target_lang}.pdf"
+        else:
+            original_name = Path(source_name).stem
+            output_filename = f"{original_name}_translated.{target_lang}.pdf"
+
+        output_path = OUTPUT_DIR / output_filename
+        output_path.write_bytes(base64.b64decode(pdf_data))
+
+        return {
+            "success": True,
+            "message": f"Translated to {SUPPORTED_LANGUAGES[target_lang]}",
+            "source": source_name,
+            "page_count": page_count,
+            "output_file": str(output_path),
+            "filename": output_filename,
+            "stats": result.get("stats", {}),
+        }
+
+    except httpx.TimeoutException:
+        return {"success": False, "message": "Translation timed out (max 15 min)"}
+    except Exception as e:
+        return {"success": False, "message": f"Error: {str(e)}"}
+
+
+@mcp.tool()
+async def translate_and_upload(source: str, target_lang: str = "fr", folder_id: Optional[str] = None) -> dict:
+    """Translate PDF and upload to Google Drive."""
+    result = await translate_pdf(source, target_lang)
+    if not result.get("success"):
+        return result
+
+    file_id, error = _upload_to_gdrive(result["output_file"], folder_id)
+    if error:
+        return {"success": False, "message": error, "local_file": result["output_file"]}
+
+    return {
+        "success": True,
+        "message": f"Translated and uploaded to Google Drive",
+        "source": result.get("source"),
+        "page_count": result.get("page_count"),
+        "gdrive_id": file_id,
+        "gdrive_link": f"https://drive.google.com/file/d/{file_id}/view",
+        "local_file": result["output_file"],
+    }
+
+
+@mcp.tool()
+async def check_pdf(source: str) -> dict:
+    """Check if PDF can be translated (page count)."""
+    await _warmup_modal()
+
+    try:
+        pdf_bytes, source_name, error = await _get_pdf_bytes(source)
+        if error:
+            return {"success": False, "message": error}
+
+        page_count = _count_pdf_pages(pdf_bytes)
+        can_translate = page_count <= MAX_PAGES
+
+        return {
+            "success": True,
+            "source": source_name,
+            "pages": page_count,
+            "size_mb": round(len(pdf_bytes) / (1024 * 1024), 2),
+            "can_translate": can_translate,
+            "message": f"Ready ({page_count} pages)" if can_translate else f"Too large ({page_count} > {MAX_PAGES})"
+        }
+    except Exception as e:
+        return {"success": False, "message": f"Error: {str(e)}"}
+
+
+@mcp.tool()
+async def get_supported_languages() -> dict:
+    """Get supported languages."""
+    return {"languages": SUPPORTED_LANGUAGES, "default": "fr"}
+
+
+@mcp.tool()
+async def upload_to_gdrive(file_path: str, folder_id: Optional[str] = None) -> dict:
+    """Upload file to Google Drive."""
+    if not GOOGLE_AVAILABLE:
+        return {"success": False, "message": "Google libraries not installed"}
+
+    path = Path(file_path)
+    if not path.exists():
+        return {"success": False, "message": f"File not found: {file_path}"}
+
+    file_id, error = _upload_to_gdrive(file_path, folder_id)
+    if error:
+        return {"success": False, "message": error}
+
+    return {
+        "success": True,
+        "message": f"Uploaded {path.name}",
+        "file_id": file_id,
+        "web_link": f"https://drive.google.com/file/d/{file_id}/view",
+    }
+
+
+@mcp.tool()
+async def list_gdrive_folders() -> dict:
+    """List Google Drive folders."""
+    if not GOOGLE_AVAILABLE:
+        return {"success": False, "message": "Google libraries not installed"}
+
+    folders, error = _list_gdrive_folders()
+    if error:
+        return {"success": False, "message": error}
+
+    return {"success": True, "folders": folders, "count": len(folders)}
+
+
+@mcp.tool()
+async def list_gdrive_files(folder_id: Optional[str] = None, file_type: Optional[str] = None) -> dict:
+    """List files in Google Drive."""
+    if not GOOGLE_AVAILABLE:
+        return {"success": False, "message": "Google libraries not installed"}
+
+    files, error = _list_gdrive_files(folder_id, file_type)
+    if error:
+        return {"success": False, "message": error}
+
+    for f in files:
+        if f.get('size'):
+            f['size_mb'] = round(int(f['size']) / (1024 * 1024), 2)
+
+    return {"success": True, "files": files, "count": len(files)}
+
+
+@mcp.tool()
+async def search_gdrive(query: str, file_type: Optional[str] = None) -> dict:
+    """Search Google Drive by filename."""
+    if not GOOGLE_AVAILABLE:
+        return {"success": False, "message": "Google libraries not installed"}
+
+    files, error = _search_gdrive_files(query, file_type)
+    if error:
+        return {"success": False, "message": error}
+
+    for f in files:
+        if f.get('size'):
+            f['size_mb'] = round(int(f['size']) / (1024 * 1024), 2)
+
+    return {"success": True, "query": query, "files": files, "count": len(files)}
+
+
+@mcp.tool()
+async def download_from_gdrive(file_id: str) -> dict:
+    """Download file from Google Drive."""
+    if not GOOGLE_AVAILABLE:
+        return {"success": False, "message": "Google libraries not installed"}
+
+    local_path, error = _download_gdrive_file(file_id)
+    if error:
+        return {"success": False, "message": error}
+
+    return {
+        "success": True,
+        "message": f"Downloaded to {local_path}",
+        "local_path": local_path,
+        "filename": Path(local_path).name,
+    }
+
+
+if __name__ == "__main__":
+    mcp.run()