Create app.py

app.py

@@ -0,0 +1,756 @@
+"""
+STL Voxel Remesh - Hugging Face Space
+======================================
+Main application combining Gradio UI + FastAPI + MCP Server.
+
+Voxel remeshing via trimesh + scipy marching cubes (same algorithm as Blender).
+Lightweight alternative: ~50MB dependencies vs ~300MB+ for Blender headless.
+"""
+
+import os
+import sys
+import json
+import logging
+import tempfile
+import traceback
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+import trimesh
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi_sse import sse
+import gradio as gr
+import plotly.graph_objects as go
+
+# Import our core module
+from voxel_remesh import (
+    load_stl,
+    voxel_remesh,
+    save_stl,
+    get_mesh_stats,
+    RemeshResult
+)
+
+# ─── Logging ────────────────────────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(name)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+# ─── FastAPI App ────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="STL Voxel Remesh API",
+    description="API for voxel-based remeshing of STL files. Includes MCP-compatible endpoints.",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ─── MCP Server Implementation ──────────────────────────────────────────────
+# MCP (Model Context Protocol) allows AI agents to use this tool.
+# We implement MCP-compatible JSON-RPC endpoints on the FastAPI server.
+
+MCP_SERVER_NAME = "stl-voxel-remesh"
+MCP_SERVER_VERSION = "1.0.0"
+
+MCP_TOOLS = [
+    {
+        "name": "voxel_remesh",
+        "description": "Perform voxel-based remeshing on an STL file to fix triangles, repair topology, and produce a clean mesh with uniform triangles without deforming the model.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "voxel_size": {
+                    "type": "number",
+                    "description": "Size of each voxel cube in world units. Smaller = more detail preserved, more triangles. Default: auto-estimated.",
+                    "default": None
+                },
+                "adapt_voxels": {
+                    "type": "boolean",
+                    "description": "Auto-estimate voxel size based on mesh analysis. Recommended for most cases.",
+                    "default": True
+                },
+                "target_reduction": {
+                    "type": "number",
+                    "description": "Target face count reduction ratio (0.0-0.9). 0.5 = reduce faces by ~50%.",
+                    "default": 0.5,
+                    "minimum": 0.0,
+                    "maximum": 0.9
+                },
+                "smooth_iterations": {
+                    "type": "number",
+                    "description": "Number of smoothing passes (0-10). 0 = no smoothing, preserves sharp edges.",
+                    "default": 2,
+                    "minimum": 0,
+                    "maximum": 10
+                },
+                "fill_holes": {
+                    "type": "boolean",
+                    "description": "Attempt to close holes during voxelization.",
+                    "default": True
+                }
+            },
+            "required": []
+        }
+    },
+    {
+        "name": "mesh_info",
+        "description": "Get comprehensive statistics about an STL mesh: vertex/face count, watertight status, volume, bounding box, edge quality metrics.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    }
+]
+
+
+@app.post("/mcp", tags=["MCP"])
+async def mcp_handler(request: dict):
+    """MCP-compatible JSON-RPC endpoint.
+    
+    Supports the Model Context Protocol for AI agent tool integration.
+    Implements: initialize, tools/list, tools/call
+    
+    Usage:
+        POST /mcp
+        {
+            "jsonrpc": "2.0",
+            "method": "tools/list",
+            "id": 1
+        }
+    """
+    method = request.get("method", "")
+    request_id = request.get("id")
+    params = request.get("params", {})
+    
+    logger.info(f"MCP request: {method} (id={request_id})")
+    
+    try:
+        if method == "initialize":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {
+                        "tools": {}
+                    },
+                    "serverInfo": {
+                        "name": MCP_SERVER_NAME,
+                        "version": MCP_SERVER_VERSION
+                    }
+                }
+            }
+        
+        elif method == "notifications/initialized":
+            return {"jsonrpc": "2.0", "id": request_id, "result": {}}
+        
+        elif method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "tools": MCP_TOOLS
+                }
+            }
+        
+        elif method == "tools/call":
+            tool_name = params.get("name", "")
+            arguments = params.get("arguments", {})
+            
+            if tool_name == "voxel_remesh":
+                return await _mcp_voxel_remesh(params, arguments, request_id)
+            elif tool_name == "mesh_info":
+                return await _mcp_mesh_info(params, request_id)
+            else:
+                return _mcp_error(request_id, -32601, f"Unknown tool: {tool_name}")
+        
+        elif method == "ping":
+            return {"jsonrpc": "2.0", "id": request_id, "result": {}}
+        
+        else:
+            return _mcp_error(request_id, -32601, f"Method not found: {method}")
+    
+    except Exception as e:
+        logger.error(f"MCP error: {traceback.format_exc()}")
+        return _mcp_error(request_id, -32603, str(e))
+
+
+async def _mcp_voxel_remesh(params: dict, arguments: dict, request_id):
+    """Handle MCP voxel_remesh tool call."""
+    # The file reference is passed via _meta or as a URL/base64
+    meta = params.get("_meta", {})
+    file_path = meta.get("file_path") or arguments.get("file_path")
+    
+    if not file_path:
+        return _mcp_error(request_id, -32602, 
+            "No file provided. Upload an STL file first via /api/remesh or use the Gradio UI.")
+    
+    try:
+        mesh = load_stl(file_path)
+        result = voxel_remesh(
+            mesh,
+            voxel_size=arguments.get("voxel_size"),
+            adapt_voxels=arguments.get("adapt_voxels", True),
+            target_reduction=arguments.get("target_reduction", 0.5),
+            smooth_iterations=arguments.get("smooth_iterations", 2),
+            fill_holes=arguments.get("fill_holes", True),
+        )
+        
+        # Save result
+        out_path = file_path.replace(".stl", "_remeshed.stl")
+        save_stl(result.mesh, out_path)
+        
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "result": {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": json.dumps({
+                            "status": "success",
+                            "output_file": out_path,
+                            "statistics": {
+                                "original_vertices": result.original_vertices,
+                                "original_faces": result.original_faces,
+                                "new_vertices": result.new_vertices,
+                                "new_faces": result.new_faces,
+                                "face_reduction_pct": round((1 - result.new_faces / max(result.original_faces, 1)) * 100, 1),
+                                "voxel_size": result.voxel_size,
+                                "was_watertight": result.was_watertight_before,
+                                "is_watertight": result.is_watertight_after,
+                                "volume_before": result.volume_before,
+                                "volume_after": result.volume_after,
+                            }
+                        }, indent=2)
+                    }
+                ]
+            }
+        }
+    except Exception as e:
+        return _mcp_error(request_id, -32603, f"Remesh failed: {str(e)}")
+
+
+async def _mcp_mesh_info(params: dict, request_id):
+    """Handle MCP mesh_info tool call."""
+    meta = params.get("_meta", {})
+    file_path = meta.get("file_path") or params.get("arguments", {}).get("file_path")
+    
+    if not file_path:
+        return _mcp_error(request_id, -32602, "No file provided.")
+    
+    try:
+        mesh = load_stl(file_path)
+        stats = get_mesh_stats(mesh)
+        
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "result": {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": json.dumps({
+                            "status": "success",
+                            "mesh_statistics": stats
+                        }, indent=2)
+                    }
+                ]
+            }
+        }
+    except Exception as e:
+        return _mcp_error(request_id, -32603, f"Mesh analysis failed: {str(e)}")
+
+
+def _mcp_error(request_id, code: int, message: str) -> dict:
+    return {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "error": {
+            "code": code,
+            "message": message
+        }
+    }
+
+
+# ─── REST API Endpoints ─────────────────────────────────────────────────────
+
+@app.post("/api/remesh", tags=["API"])
+async def api_remesh(
+    file: UploadFile = File(...),
+    voxel_size: Optional[float] = None,
+    adapt_voxels: bool = True,
+    target_reduction: float = 0.5,
+    smooth_iterations: int = 2,
+    fill_holes: bool = True
+):
+    """REST endpoint for voxel remeshing. Upload STL, get remeshed STL."""
+    if not file.filename.lower().endswith('.stl'):
+        raise HTTPException(400, "Only STL files are supported")
+    
+    with tempfile.NamedTemporaryFile(suffix='.stl', delete=False) as tmp:
+        content = await file.read()
+        tmp.write(content)
+        tmp_path = tmp.name
+    
+    try:
+        mesh = load_stl(tmp_path)
+        result = voxel_remesh(
+            mesh,
+            voxel_size=voxel_size,
+            adapt_voxels=adapt_voxels,
+            target_reduction=target_reduction,
+            smooth_iterations=smooth_iterations,
+            fill_holes=fill_holes
+        )
+        
+        out_path = tmp_path.replace('.stl', '_remeshed.stl')
+        save_stl(result.mesh, out_path)
+        
+        stats = {
+            "original_vertices": result.original_vertices,
+            "original_faces": result.original_faces,
+            "new_vertices": result.new_vertices,
+            "new_faces": result.new_faces,
+            "face_reduction_pct": round((1 - result.new_faces / max(result.original_faces, 1)) * 100, 1),
+            "voxel_size_used": result.voxel_size,
+            "was_watertight": result.was_watertight_before,
+            "is_watertight_after": result.is_watertight_after
+        }
+        
+        return FileResponse(
+            out_path,
+            media_type="model/stl",
+            filename=file.filename.replace('.stl', '_remeshed.stl'),
+            headers={"X-Mesh-Stats": json.dumps(stats)}
+        )
+    except Exception as e:
+        logger.error(f"API remesh error: {traceback.format_exc()}")
+        raise HTTPException(500, f"Remeshing failed: {str(e)}")
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+
+@app.post("/api/info", tags=["API"])
+async def api_info(file: UploadFile = File(...)):
+    """REST endpoint to get mesh statistics."""
+    if not file.filename.lower().endswith('.stl'):
+        raise HTTPException(400, "Only STL files are supported")
+    
+    with tempfile.NamedTemporaryFile(suffix='.stl', delete=False) as tmp:
+        content = await file.read()
+        tmp.write(content)
+        tmp_path = tmp.name
+    
+    try:
+        mesh = load_stl(tmp_path)
+        stats = get_mesh_stats(mesh)
+        return JSONResponse(content=stats)
+    except Exception as e:
+        raise HTTPException(500, str(e))
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+
+@app.get("/api/health", tags=["API"])
+async def health():
+    return {"status": "healthy", "service": "stl-voxel-remesh", "mcp_available": True}
+
+
+# ─── Gradio UI ──────────────────────────────────────────────────────────────
+
+def mesh_to_plotly(mesh: trimesh.Trimesh, title: str = "Mesh") -> go.Figure:
+    """Convert a trimesh object to a Plotly 3D mesh figure."""
+    # Simplify mesh for rendering if too many faces (>100k)
+    render_mesh = mesh
+    if len(mesh.faces) > 100000:
+        render_mesh = mesh.simplify_quadratic_error_decimation(100000)
+    
+    vertices = render_mesh.vertices
+    faces = render_mesh.faces
+    
+    # Create Plotly mesh3d trace
+    fig = go.Figure(data=[go.Mesh3d(
+        x=vertices[:, 0],
+        y=vertices[:, 1],
+        z=vertices[:, 2],
+        i=faces[:, 0],
+        j=faces[:, 1],
+        k=faces[:, 2],
+        color='#4facfe',
+        opacity=0.9,
+        flatshading=True,
+        lighting=dict(
+            ambient=0.4,
+            diffuse=0.6,
+            specular=0.2,
+            roughness=0.5,
+            fresnel=0.3
+        ),
+        lightposition=dict(
+            x=1000,
+            y=1000,
+            z=2000
+        ),
+        hoverinfo='skip'
+    )])
+    
+    fig.update_layout(
+        title=dict(text=title, font=dict(size=14)),
+        scene=dict(
+            aspectmode='data',
+            bgcolor='rgba(0,0,0,0)',
+            xaxis=dict(showgrid=False, showticklabels=False, title=''),
+            yaxis=dict(showgrid=False, showticklabels=False, title=''),
+            zaxis=dict(showgrid=False, showticklabels=False, title=''),
+        ),
+        margin=dict(l=0, r=0, t=40, b=0),
+        height=400,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+    )
+    
+    return fig
+
+
+def build_comparison_html(result: RemeshResult) -> str:
+    """Build an HTML comparison card showing before/after statistics."""
+    reduction_pct = (1 - result.new_faces / max(result.original_faces, 1)) * 100
+    
+    watertight_before = "✅ Sí" if result.was_watertight_before else "❌ No"
+    watertight_after = "✅ Sí" if result.is_watertight_after else "❌ No"
+    
+    # Volume comparison if available
+    volume_info = ""
+    if result.volume_before and result.volume_after:
+        vol_diff = abs(result.volume_before - result.volume_after)
+        vol_pct = (vol_diff / result.volume_before) * 100 if result.volume_before > 0 else 0
+        volume_info = f"""
+        <div style="grid-column: span 2; padding: 8px; background: #1a1a2e; border-radius: 8px; text-align: center;">
+            <div style="color: #aaa; font-size: 11px;">Preservación de Volumen</div>
+            <div style="color: #00d4ff; font-size: 20px; font-weight: bold;">{vol_pct:.1f}%</div>
+            <div style="color: #aaa; font-size: 11px;">{result.volume_before:.2f} → {result.volume_after:.2f} unidades³</div>
+        </div>
+        """
+    
+    html = f"""
+    <div style="font-family: 'Inter', system-ui, sans-serif; max-width: 600px;">
+        <div style="display: grid; grid-template-columns: 1fr auto 1fr; gap: 12px; align-items: center;">
+            
+            <!-- Original -->
+            <div style="background: #1a1a2e; padding: 16px; border-radius: 12px; border: 1px solid #2a2a4a;">
+                <div style="text-align: center; color: #ff6b6b; font-weight: bold; font-size: 13px; margin-bottom: 12px;">
+                    📥 ORIGINAL
+                </div>
+                <div style="text-align: center;">
+                    <div style="color: #ffd93d; font-size: 28px; font-weight: bold;">{result.original_faces:,}</div>
+                    <div style="color: #aaa; font-size: 11px;">caras</div>
+                </div>
+                <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid #2a2a4a;">
+                    <div style="color: #aaa; font-size: 11px;">Vértices: <span style="color: #eee;">{result.original_vertices:,}</span></div>
+                    <div style="color: #aaa; font-size: 11px; margin-top: 4px;">Estanco: {watertight_before}</div>
+                </div>
+            </div>
+            
+            <!-- Arrow -->
+            <div style="text-align: center; color: #4facfe; font-size: 24px;">→</div>
+            
+            <!-- Remeshed -->
+            <div style="background: #1a1a2e; padding: 16px; border-radius: 12px; border: 1px solid #2a2a4a;">
+                <div style="text-align: center; color: #51cf66; font-weight: bold; font-size: 13px; margin-bottom: 12px;">
+                    🔧 REMESHED
+                </div>
+                <div style="text-align: center;">
+                    <div style="color: #51cf66; font-size: 28px; font-weight: bold;">{result.new_faces:,}</div>
+                    <div style="color: #aaa; font-size: 11px;">caras</div>
+                </div>
+                <div style="margin-top: 8px; padding-top: 8px; border-top: 1px solid #2a2a4a;">
+                    <div style="color: #aaa; font-size: 11px;">Vértices: <span style="color: #eee;">{result.new_vertices:,}</span></div>
+                    <div style="color: #aaa; font-size: 11px; margin-top: 4px;">Estanco: {watertight_after}</div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Summary -->
+        <div style="display: grid; grid-template-columns: 1fr 1fr {('1fr' if volume_info else '')}; gap: 12px; margin-top: 16px;">
+            <div style="padding: 12px; background: linear-gradient(135deg, #1a1a2e, #16213e); border-radius: 10px; text-align: center;">
+                <div style="color: #aaa; font-size: 11px;">Reducción de caras</div>
+                <div style="color: {'#ff6b6b' if reduction_pct > 0 else '#51cf66'}; font-size: 22px; font-weight: bold;">
+                    {'−' if reduction_pct > 0 else '+'}{abs(reduction_pct):.1f}%
+                </div>
+            </div>
+            <div style="padding: 12px; background: linear-gradient(135deg, #1a1a2e, #16213e); border-radius: 10px; text-align: center;">
+                <div style="color: #aaa; font-size: 11px;">Tamaño de voxel</div>
+                <div style="color: #4facfe; font-size: 22px; font-weight: bold;">{result.voxel_size:.4f}</div>
+            </div>
+            {volume_info}
+        </div>
+    </div>
+    """
+    return html
+
+
+def process_file(
+    file,
+    voxel_size: float,
+    adapt_voxels: bool,
+    target_reduction: float,
+    smooth_iterations: int,
+    fill_holes: bool
+):
+    """Main processing function called by Gradio."""
+    if file is None:
+        return None, None, None, "⚠️ Por favor sube un archivo STL"
+    
+    try:
+        # Load mesh
+        mesh = load_stl(file)
+        
+        # Create original mesh visualization
+        fig_original = mesh_to_plotly(mesh, f"Original ({len(mesh.faces):,} caras)")
+        
+        # Perform voxel remesh
+        vs = float(voxel_size) if voxel_size and voxel_size > 0 else None
+        result = voxel_remesh(
+            mesh,
+            voxel_size=vs,
+            adapt_voxels=adapt_voxels,
+            target_reduction=float(target_reduction),
+            smooth_iterations=int(smooth_iterations),
+            fill_holes=fill_holes
+        )
+        
+        # Create remeshed visualization
+        fig_remeshed = mesh_to_plotly(result.mesh, f"Remeshed ({result.new_faces:,} caras)")
+        
+        # Save output file
+        out_path = tempfile.mktemp(suffix='_remeshed.stl')
+        save_stl(result.mesh, out_path)
+        
+        # Build stats HTML
+        stats_html = build_comparison_html(result)
+        
+        # Build summary text
+        reduction = (1 - result.new_faces / max(result.original_faces, 1)) * 100
+        summary = (
+            f"✅ Remesh completado con éxito.\n\n"
+            f"📊 Resumen:\n"
+            f"  • Caras: {result.original_faces:,} → {result.new_faces:,} "
+            f"({'−' if reduction > 0 else '+'}{abs(reduction):.1f}%)\n"
+            f"  • Vértices: {result.original_vertices:,} → {result.new_vertices:,}\n"
+            f"  • Voxel size: {result.voxel_size:.4f}\n"
+            f"  • Estanco: {result.was_watertight_before} → {result.is_watertight_after}\n"
+        )
+        
+        return fig_original, fig_remeshed, out_path, stats_html
+    
+    except Exception as e:
+        logger.error(f"Processing error: {traceback.format_exc()}")
+        return None, None, None, f"❌ Error: {str(e)}"
+
+
+def create_gradio_ui() -> gr.Blocks:
+    """Build the Gradio UI with custom styling."""
+    
+    with gr.Blocks(
+        title="STL Voxel Remesh",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="slate",
+        ),
+        css="""
+        .gradio-container {
+            max-width: 1100px !important;
+        }
+        .dark .gradio-container {
+            background: #0d1117 !important;
+        }
+        #header-title {
+            text-align: center;
+            margin-bottom: 0.5rem;
+        }
+        #header-title h1 {
+            font-size: 2rem !important;
+            background: linear-gradient(90deg, #4facfe 0%, #00f2fe 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 0.25rem !important;
+        }
+        #header-title p {
+            color: #8b949e !important;
+            font-size: 0.9rem !important;
+        }
+        .panel-section {
+            background: rgba(22, 27, 34, 0.8);
+            border: 1px solid #30363d;
+            border-radius: 12px;
+            padding: 20px;
+            margin-bottom: 16px;
+        }
+        .api-info {
+            background: rgba(13, 17, 23, 0.9);
+            border: 1px solid #21262d;
+            border-radius: 10px;
+            padding: 16px;
+            margin-top: 16px;
+        }
+        .api-info code {
+            background: rgba(79, 172, 254, 0.15);
+            color: #4facfe;
+            padding: 2px 6px;
+            border-radius: 4px;
+            font-size: 0.85rem;
+        }
+        """
+    ) as demo:
+        
+        # ── Header ──────────────────────────────────────────────────
+        with gr.Column(elem_id="header-title"):
+            gr.Markdown(
+                "# 🧊 STL Voxel Remesh"
+                "\nSube un archivo STL, repara la malla con voxel remesh sin deformar el modelo. "
+                "[MCP](#api-info) integrado para agentes AI."
+            )
+        
+        with gr.Row():
+            # ── Left Column: Controls ───────────────────────────────
+            with gr.Column(scale=1):
+                gr.Markdown("### 📁 Archivo de entrada")
+                file_input = gr.File(
+                    label="Archivo STL",
+                    file_types=[".stl"],
+                    type="filepath"
+                )
+                
+                gr.Markdown("### ⚙️ Parámetros de Remesh")
+                
+                with gr.Group():
+                    adapt_voxels = gr.Checkbox(
+                        label="🔄 Auto-estimar tamaño de voxel",
+                        value=True,
+                        info="Recomendado. Analiza la malla para encontrar el tamaño óptimo."
+                    )
+                    
+                    with gr.Row():
+                        voxel_size = gr.Number(
+                            label="Tamaño de voxel (manual)",
+                            value=0.0,
+                            precision=4,
+                            minimum=0.0,
+                            info="Ignorado si auto-estimar está activo"
+                        )
+                        target_reduction = gr.Slider(
+                            label="Reducción objetivo",
+                            minimum=0.0,
+                            maximum=0.9,
+                            value=0.5,
+                            step=0.05,
+                            info="0.5 = reducir ~50% de caras"
+                        )
+                    
+                    with gr.Row():
+                        smooth_iterations = gr.Slider(
+                            label="Suavizado",
+                            minimum=0,
+                            maximum=10,
+                            value=2,
+                            step=1,
+                            info="0 = preservar bordes afilados"
+                        )
+                        fill_holes = gr.Checkbox(
+                            label="🔧 Rellenar agujeros",
+                            value=True,
+                            info="Cierra pequeños agujeros topológicos"
+                        )
+                
+                process_btn = gr.Button(
+                    "🚀 Aplicar Voxel Remesh",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            # ── Right Column: Results ────────────────────────────────
+            with gr.Column(scale=2):
+                gr.Markdown("### 🔍 Vista previa 3D")
+                
+                with gr.Tabs():
+                    with gr.Tab("Comparación"):
+                        with gr.Row():
+                            plot_original = gr.Plot(label="Original")
+                            plot_remeshed = gr.Plot(label="Remeshed")
+                    
+                    with gr.Tab("Estadísticas"):
+                        stats_html = gr.HTML(
+                            value="<div style='text-align:center; color:#666; padding:40px;'>"
+                                  "Sube un archivo STL y haz clic en 'Aplicar Voxel Remesh' para ver estadísticas.</div>"
+                        )
+                
+                download_output = gr.File(label="📥 Descargar STL remeshed")
+        
+        # ── Processing ──────────────────────────────────────────────
+        process_btn.click(
+            fn=process_file,
+            inputs=[file_input, voxel_size, adapt_voxels, target_reduction, 
+                    smooth_iterations, fill_holes],
+            outputs=[plot_original, plot_remeshed, download_output, stats_html]
+        )
+        
+        # ── API Info Section ────────────────────────────────────────
+        gr.HTML("""
+        <div class="api-info" id="api-info">
+            <h3 style="margin-top:0; color:#c9d1d9; font-size:14px;">🔌 API & MCP Endpoints</h3>
+            <p style="color:#8b949e; font-size:13px; margin-bottom:12px;">
+                Este Space expone endpoints REST y MCP para integración programática y agentes AI.
+            </p>
+            <div style="display:grid; gap:8px;">
+                <div>
+                    <code style="font-weight:bold;">POST /api/remesh</code>
+                    <span style="color:#8b949e; font-size:12px;"> — Sube un STL (multipart/form-data), recibe el STL remeshed</span>
+                </div>
+                <div>
+                    <code style="font-weight:bold;">POST /api/info</code>
+                    <span style="color:#8b949e; font-size:12px;"> — Obtiene estadísticas de la malla</span>
+                </div>
+                <div>
+                    <code style="font-weight:bold;">POST /mcp</code>
+                    <span style="color:#8b949e; font-size:12px;"> — MCP JSON-RPC endpoint (initialize, tools/list, tools/call)</span>
+                </div>
+                <div>
+                    <code style="font-weight:bold;">GET /api/health</code>
+                    <span style="color:#8b949e; font-size:12px;"> — Health check</span>
+                </div>
+            </div>
+        </div>
+        """)
+    
+    return demo
+
+
+# ─── Mount Gradio on FastAPI ────────────────────────────────────────────────
+
+gradio_app = create_gradio_ui()
+app = gr.mount_gradio_app(app, gradio_app, path="/")
+
+
+# ─── Main Entry Point ───────────────────────────────────────────────────────
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"Starting server on port {port}...")
+    uvicorn.run(app, host="0.0.0.0", port=port)