Create app.py

app.py

@@ -0,0 +1,181 @@
+"""
+Synapse-Base Inference API
+FastAPI server for chess move prediction
+Optimized for HF Spaces CPU environment
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import time
+import logging
+from typing import Optional
+
+from engine import SynapseEngine
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Synapse-Base Inference API",
+    description="High-performance chess engine powered by 38M parameter neural network",
+    version="3.0.0"
+)
+
+# CORS middleware (allow your frontend domain)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Change to your domain in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global engine instance (loaded once at startup)
+engine = None
+
+
+# Request/Response models
+class MoveRequest(BaseModel):
+    fen: str = Field(..., description="Board position in FEN notation")
+    depth: Optional[int] = Field(3, ge=1, le=5, description="Search depth (1-5)")
+    time_limit: Optional[int] = Field(5000, ge=1000, le=30000, description="Time limit in ms")
+
+
+class MoveResponse(BaseModel):
+    best_move: str
+    evaluation: float
+    depth_searched: int
+    nodes_evaluated: int
+    time_taken: int
+    pv: Optional[list] = None  # Principal variation
+
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    version: str
+
+
+# Startup event
+@app.on_event("startup")
+async def startup_event():
+    """Load model on startup"""
+    global engine
+    
+    logger.info("🚀 Starting Synapse-Base Inference API...")
+    
+    try:
+        engine = SynapseEngine(
+            model_path="/app/models/synapse_base.onnx",
+            num_threads=2  # Match HF Spaces 2 vCPU
+        )
+        logger.info("✅ Model loaded successfully")
+        logger.info(f"📊 Model size: {engine.get_model_size():.2f} MB")
+        
+    except Exception as e:
+        logger.error(f"❌ Failed to load model: {e}")
+        raise
+
+
+# Health check endpoint
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy" if engine is not None else "unhealthy",
+        "model_loaded": engine is not None,
+        "version": "3.0.0"
+    }
+
+
+# Main inference endpoint
+@app.post("/get-move", response_model=MoveResponse)
+async def get_move(request: MoveRequest):
+    """
+    Get best move for given position
+    
+    Args:
+        request: MoveRequest with FEN, depth, and time_limit
+    
+    Returns:
+        MoveResponse with best_move and evaluation
+    """
+    
+    if engine is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    # Validate FEN
+    if not engine.validate_fen(request.fen):
+        raise HTTPException(status_code=400, detail="Invalid FEN string")
+    
+    # Start timing
+    start_time = time.time()
+    
+    try:
+        # Get best move from engine
+        result = engine.get_best_move(
+            fen=request.fen,
+            depth=request.depth,
+            time_limit=request.time_limit
+        )
+        
+        # Calculate time taken
+        time_taken = int((time.time() - start_time) * 1000)
+        
+        # Log request
+        logger.info(
+            f"Move: {result['best_move']} | "
+            f"Eval: {result['evaluation']:.3f} | "
+            f"Depth: {result['depth_searched']} | "
+            f"Nodes: {result['nodes_evaluated']} | "
+            f"Time: {time_taken}ms"
+        )
+        
+        return MoveResponse(
+            best_move=result['best_move'],
+            evaluation=result['evaluation'],
+            depth_searched=result['depth_searched'],
+            nodes_evaluated=result['nodes_evaluated'],
+            time_taken=time_taken,
+            pv=result.get('pv', None)
+        )
+        
+    except Exception as e:
+        logger.error(f"Error processing move: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# Root endpoint
+@app.get("/")
+async def root():
+    """Root endpoint with API info"""
+    return {
+        "name": "Synapse-Base Inference API",
+        "version": "3.0.0",
+        "model": "38.1M parameters",
+        "architecture": "CNN-Transformer Hybrid",
+        "endpoints": {
+            "POST /get-move": "Get best move for position",
+            "GET /health": "Health check",
+            "GET /docs": "API documentation"
+        }
+    }
+
+
+# Run server
+if __name__ == "__main__":
+    import uvicorn
+    
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860,
+        log_level="info",
+        access_log=True
+    )