Update app.py

app.py

@@ -1,7 +1,6 @@
 """
-Synapse-Base Inference API
-FastAPI server for chess move prediction
-Optimized for HF Spaces CPU environment
+Synapse-Base Inference API (Updated)
+State-of-the-art search engine with modular architecture
 """
 
 from fastapi import FastAPI, HTTPException
@@ -9,7 +8,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 import time
 import logging
-from typing import Optional
+from typing import Optional, List
 
 from engine import SynapseEngine
 
@@ -20,30 +19,30 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Initialize FastAPI app
+# Initialize FastAPI
 app = FastAPI(
     title="Synapse-Base Inference API",
-    description="High-performance chess engine powered by 38M parameter neural network",
+    description="State-of-the-art chess engine with neural evaluation",
     version="3.0.0"
 )
 
-# CORS middleware (allow your frontend domain)
+# CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Change to your domain in production
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Global engine instance (loaded once at startup)
+# Global engine
 engine = None
 
 
-# Request/Response models
+# 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)")
+    depth: Optional[int] = Field(5, ge=1, le=10, description="Search depth (1-10)")
     time_limit: Optional[int] = Field(5000, ge=1000, le=30000, description="Time limit in ms")
 
 
@@ -51,131 +50,114 @@ class MoveResponse(BaseModel):
     best_move: str
     evaluation: float
     depth_searched: int
+    seldepth: int
     nodes_evaluated: int
     time_taken: int
-    pv: Optional[list] = None  # Principal variation
+    nps: int
+    pv: List[str]
+    tt_hit_rate: Optional[float] = None
 
 
 class HealthResponse(BaseModel):
     status: str
     model_loaded: bool
     version: str
+    model_size_mb: Optional[float] = None
 
 
-# Startup event
+# Startup
 @app.on_event("startup")
 async def startup_event():
-    """Load model on startup"""
     global engine
     
-    logger.info("🚀 Starting Synapse-Base Inference API...")
+    logger.info("🚀 Starting Synapse-Base Inference API v3.0...")
     
     try:
         engine = SynapseEngine(
             model_path="/app/models/synapse_base.onnx",
-            num_threads=2  # Match HF Spaces 2 vCPU
+            num_threads=2
         )
-        logger.info("✅ Model loaded successfully")
-        logger.info(f"📊 Model size: {engine.get_model_size():.2f} MB")
+        logger.info("✅ Engine loaded successfully")
         
     except Exception as e:
-        logger.error(f"❌ Failed to load model: {e}")
+        logger.error(f"❌ Failed to load engine: {e}")
         raise
 
 
-# Health check endpoint
+# Health check
 @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"
+        "version": "3.0.0",
+        "model_size_mb": engine.get_model_size() if engine else None
     }
 
 
-# Main inference endpoint
+# Main 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")
+        raise HTTPException(status_code=503, detail="Engine 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"Eval: {result['evaluation']:+.2f} | "
+            f"Depth: {result['depth_searched']}/{result['seldepth']} | "
             f"Nodes: {result['nodes_evaluated']} | "
-            f"Time: {time_taken}ms"
+            f"Time: {time_taken}ms | "
+            f"NPS: {result['nps']}"
         )
         
         return MoveResponse(
             best_move=result['best_move'],
             evaluation=result['evaluation'],
             depth_searched=result['depth_searched'],
+            seldepth=result['seldepth'],
             nodes_evaluated=result['nodes_evaluated'],
             time_taken=time_taken,
-            pv=result.get('pv', None)
+            nps=result['nps'],
+            pv=result['pv'],
+            tt_hit_rate=result['tt_stats']['hit_rate']
         )
         
     except Exception as e:
-        logger.error(f"Error processing move: {e}")
+        logger.error(f"Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 
-# Root endpoint
+# Root
 @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",
+        "search": "PVS + NMP + LMR + TT",
         "endpoints": {
-            "POST /get-move": "Get best move for position",
+            "POST /get-move": "Get best move",
             "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
-    )
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")