Create railway_app.py

railway_app.py

@@ -1,88 +1,67 @@
 import os
-import logging
+import uvicorn
 from fastapi import FastAPI, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-import uvicorn
-from typing import List, Optional, Dict, Any
-import json
+from typing import Optional, List, Dict
 import time
-import asyncio
-from contextlib import asynccontextmanager
-import psutil
-import GPUtil
+from datetime import datetime
+import logging
 
-# Import our AI system
-from saems_ai_system import SaemsTunesAISystem
+from src.ai_system import SaemsTunesAISystem
+from src.supabase_integration import SupabaseIntegration
+from src.security_system import SecuritySystem
+from src.monitoring_system import ComprehensiveMonitor
 
 # Configuration
 class Config:
+    SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+    SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY", "")
+    MODEL_NAME = os.getenv("MODEL_NAME", "microsoft/Phi-3.5-mini-instruct")
     PORT = int(os.getenv("PORT", 8000))
-    MODEL_DIR = os.getenv("MODEL_DIR", "./models")
-    LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
-    MAX_REQUEST_SIZE = int(os.getenv("MAX_REQUEST_SIZE", 1024 * 1024))  # 1MB
+    ENVIRONMENT = os.getenv("RAILWAY_ENVIRONMENT", "production")
 
 # Request/Response models
 class ChatRequest(BaseModel):
     message: str
+    user_id: Optional[str] = "anonymous"
     conversation_id: Optional[str] = None
-    model_profile: Optional[str] = "fast"
-    temperature: Optional[float] = 0.7
-    max_tokens: Optional[int] = 300
 
 class ChatResponse(BaseModel):
     response: str
-    conversation_id: str
     processing_time: float
+    conversation_id: str
+    timestamp: str
     model_used: str
-    tokens_used: int
 
 class HealthResponse(BaseModel):
     status: str
-    models_loaded: int
-    memory_usage: float
-    uptime: float
-
-class PerformanceStats(BaseModel):
-    total_requests: int
-    average_response_time: float
-    models_available: List[str]
-    system_health: Dict[str, Any]
-
-# Global AI system instance
-ai_system = None
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup
-    global ai_system
-    print("🚀 INITIALIZING SAEM'S TUNES AI PRODUCTION SYSTEM")
-    
-    # Initialize AI system
-    ai_system = SaemsTunesAISystem()
-    
-    # Load models in background
-    async def load_models():
-        ai_system.load_models()
-        print("✅ MODELS LOADED SUCCESSFULLY")
-    
-    asyncio.create_task(load_models())
-    
-    yield  # Application runs here
-    
-    # Shutdown
-    print("🛑 SHUTTING DOWN AI SYSTEM")
-    if ai_system:
-        # Cleanup resources
-        pass
+    timestamp: str
+    version: str
+    environment: str
+    systems: Dict
+    resources: Dict
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize systems
+print("🚀 Initializing Saem's Tunes AI System for Railway...")
+
+supabase_integration = SupabaseIntegration(Config.SUPABASE_URL, Config.SUPABASE_ANON_KEY)
+security_system = SecuritySystem()
+monitor = ComprehensiveMonitor()
+ai_system = SaemsTunesAISystem(supabase_integration, security_system, monitor)
 
 # Create FastAPI application
 app = FastAPI(
     title="Saem's Tunes AI API",
-    description="Production AI API for Saem's Tunes music platform",
+    description="Backup AI API for Saem's Tunes music platform",
     version="1.0.0",
-    lifespan=lifespan
+    docs_url="/docs",
+    redoc_url="/redoc"
 )
 
 # CORS middleware
@@ -94,131 +73,121 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Middleware for logging and monitoring
-@app.middleware("http")
-async def log_requests(request, call_next):
-    start_time = time.time()
-    
-    response = await call_next(request)
-    
-    process_time = time.time() - start_time
-    logging.info(f"{request.method} {request.url.path} - {response.status_code} - {process_time:.2f}s")
-    
-    response.headers["X-Process-Time"] = str(process_time)
-    return response
-
-# Routes
-@app.get("/")
+# Health check endpoint
+@app.get("/", response_model=HealthResponse)
 async def root():
-    return {
-        "message": "Saem's Tunes AI API",
-        "version": "1.0.0",
-        "status": "operational",
-        "documentation": "/docs"
-    }
-
-@app.get("/health")
-async def health_check() -> HealthResponse:
-    if not ai_system or not ai_system.models:
-        return HealthResponse(
-            status="initializing",
-            models_loaded=0,
-            memory_usage=psutil.virtual_memory().percent,
-            uptime=time.time() - start_time
-        )
+    """Root endpoint with health information"""
+    import psutil
     
     return HealthResponse(
         status="healthy",
-        models_loaded=len(ai_system.models),
-        memory_usage=psutil.virtual_memory().percent,
-        uptime=time.time() - start_time
+        timestamp=datetime.now().isoformat(),
+        version="1.0.0",
+        environment=Config.ENVIRONMENT,
+        systems={
+            "supabase": supabase_integration.is_connected(),
+            "security": True,
+            "monitoring": True,
+            "ai_system": True
+        },
+        resources={
+            "cpu_percent": psutil.cpu_percent(),
+            "memory_percent": psutil.virtual_memory().percent,
+            "disk_percent": psutil.disk_usage('/').percent
+        }
     )
 
-@app.post("/chat", response_model=ChatResponse)
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return await root()
+
+@app.post("/api/chat", response_model=ChatResponse)
 async def chat_endpoint(request: ChatRequest):
-    if not ai_system or not ai_system.models:
-        raise HTTPException(status_code=503, detail="AI system still initializing")
-    
+    """Main chat endpoint for React frontend"""
     try:
-        # Generate response
-        result = ai_system.generate_response(
-            query=request.message,
-            history=[],  # Would load from conversation_id
-            model_profile=request.model_profile
-        )
+        if not request.message.strip():
+            raise HTTPException(status_code=400, detail="Message cannot be empty")
+        
+        # Security check
+        security_result = security_system.check_request(request.message, request.user_id)
+        if security_result.get("is_suspicious", False):
+            raise HTTPException(
+                status_code=429, 
+                detail="Request blocked for security reasons"
+            )
+        
+        # Process query
+        start_time = time.time()
+        response = ai_system.process_query(request.message, request.user_id, request.conversation_id)
+        processing_time = time.time() - start_time
         
         return ChatResponse(
-            response=result["response"],
-            conversation_id=request.conversation_id or generate_conversation_id(),
-            processing_time=result["processing_time"],
-            model_used=result["model_used"],
-            tokens_used=result.get("tokens_used", 0)
+            response=response,
+            processing_time=processing_time,
+            conversation_id=request.conversation_id or f"conv_{int(time.time())}",
+            timestamp=datetime.now().isoformat(),
+            model_used=Config.MODEL_NAME
         )
         
+    except HTTPException:
+        raise
     except Exception as e:
-        logging.error(f"Chat error: {e}")
-        raise HTTPException(status_code=500, detail="Error processing request")
+        logger.error(f"Chat endpoint error: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
 
-@app.get("/models")
-async def list_models():
-    if not ai_system:
-        return {"models": []}
-    
-    models = []
-    for profile, model in ai_system.models.items():
-        models.append({
-            "profile": profile,
-            "context_size": model.n_ctx(),
-            "parameters": "3.8B",
-            "quantization": profile.upper()
-        })
-    
-    return {"models": models}
-
-@app.get("/performance")
-async def get_performance_stats() -> PerformanceStats:
-    if not ai_system:
-        return PerformanceStats(
-            total_requests=0,
-            average_response_time=0,
-            models_available=[],
-            system_health={}
-        )
-    
-    stats = ai_system.performance_monitor.get_performance_stats()
-    
-    return PerformanceStats(
-        total_requests=stats.get("total_inferences", 0),
-        average_response_time=stats.get("average_time", 0),
-        models_available=list(ai_system.models.keys()),
-        system_health={
-            "memory_percent": psutil.virtual_memory().percent,
-            "cpu_percent": psutil.cpu_percent(),
-            "disk_usage": psutil.disk_usage('/').percent
-        }
-    )
+@app.get("/api/models")
+async def get_models():
+    """Get available models information"""
+    return {
+        "available_models": ["microsoft/Phi-3.5-mini-instruct"],
+        "current_model": Config.MODEL_NAME,
+        "quantization": "Q4_K_M",
+        "context_length": 4096,
+        "parameters": "3.8B"
+    }
 
-@app.post("/feedback")
-async def submit_feedback(conversation_id: str, helpful: bool, comments: Optional[str] = None):
-    # Store feedback for model improvement
-    logging.info(f"Feedback for {conversation_id}: helpful={helpful}, comments={comments}")
-    return {"status": "feedback_received"}
+@app.get("/api/stats")
+async def get_stats():
+    """Get system statistics"""
+    return {
+        "total_requests": len(monitor.inference_metrics),
+        "average_response_time": monitor.get_average_response_time(),
+        "error_rate": monitor.get_error_rate(),
+        "uptime": monitor.get_uptime()
+    }
 
-# Utility functions
-def generate_conversation_id() -> str:
-    return f"conv_{int(time.time())}_{os.urandom(4).hex()}"
+# Error handlers
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"error": exc.detail}
+    )
 
-# Global startup time
-start_time = time.time()
+@app.exception_handler(Exception)
+async def general_exception_handler(request, exc):
+    logger.error(f"Unhandled exception: {exc}")
+    return JSONResponse(
+        status_code=500,
+        content={"error": "Internal server error"}
+    )
 
-# Railway-specific configuration
+# Startup event
+@app.on_event("startup")
+async def startup_event():
+    """Initialize systems on startup"""
+    print("✅ Saem's Tunes AI API is ready!")
+    print(f"📍 Environment: {Config.ENVIRONMENT}")
+    print(f"🔗 Supabase: {'Connected' if supabase_integration.is_connected() else 'Disconnected'}")
+    print(f"🤖 Model: {Config.MODEL_NAME}")
+    print(f"🌐 API docs: http://localhost:{Config.PORT}/docs")
+
+# Main entry point
 if __name__ == "__main__":
-    config = Config()
-    
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=config.PORT,
-        log_level=config.LOG_LEVEL.lower(),
-        access_log=True
+        port=Config.PORT,
+        log_level="info"
     )