Upload 3 files

Dockerfile

@@ -24,8 +24,8 @@ ENV PYTHONUNBUFFERED=1
 ENV PYTHONDONTWRITEBYTECODE=1
 
 # Health check for container monitoring
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+HEALTHCHECK --interval=60s --timeout=15s --start-period=60s --retries=5 \
     CMD curl -f http://localhost:7860/health || exit 1
 
-# Run MCP Server with SSE transport
-CMD ["uvicorn", "mcp_server_sse:app", "--host", "0.0.0.0", "--port", "7860", "--timeout-keep-alive", "75", "--limit-concurrency", "200", "--log-level", "info"]
+# Run MCP Server with SSE transport - optimized settings for CPU UPGRADE
+CMD ["uvicorn", "mcp_server_sse:app", "--host", "0.0.0.0", "--port", "7860", "--timeout-keep-alive", "120", "--limit-concurrency", "50", "--backlog", "100", "--log-level", "info", "--workers", "1"]

edgar_client.py

@@ -7,26 +7,76 @@ except ImportError:
     EdgarClient = None
 import json
 import time
+from functools import wraps
 
 
 class EdgarDataClient:
     def __init__(self, user_agent="Juntao Peng Financial Report Metrics App (jtyxabc@gmail.com)"):
         """Initialize EDGAR client"""
         self.user_agent = user_agent
+        self.last_request_time = 0
+        self.min_request_interval = 0.11  # SEC allows 10 requests/second, use 0.11s to be safe
+        self.request_timeout = 30  # 30 seconds timeout for HTTP requests
+        self.max_retries = 3  # Maximum retry attempts
+        
         if EdgarClient:
             self.edgar = EdgarClient(user_agent=user_agent)
         else:
             self.edgar = None
+    
+    def _rate_limit(self):
+        """Rate limiting to comply with SEC API limits (10 requests/second)"""
+        current_time = time.time()
+        time_since_last_request = current_time - self.last_request_time
+        
+        if time_since_last_request < self.min_request_interval:
+            sleep_time = self.min_request_interval - time_since_last_request
+            time.sleep(sleep_time)
+        
+        self.last_request_time = time.time()
+    
+    def _make_request_with_retry(self, url, headers=None):
+        """Make HTTP request with retry logic and timeout"""
+        if headers is None:
+            headers = {"User-Agent": self.user_agent}
+        
+        for attempt in range(self.max_retries):
+            try:
+                self._rate_limit()
+                response = requests.get(url, headers=headers, timeout=self.request_timeout)
+                response.raise_for_status()
+                return response
+            except requests.exceptions.Timeout:
+                print(f"Request timeout (attempt {attempt + 1}/{self.max_retries}): {url}")
+                if attempt == self.max_retries - 1:
+                    raise
+                time.sleep(2 ** attempt)  # Exponential backoff
+            except requests.exceptions.HTTPError as e:
+                if e.response.status_code == 429:  # Too Many Requests
+                    wait_time = 2 ** attempt
+                    print(f"Rate limited, waiting {wait_time}s (attempt {attempt + 1}/{self.max_retries})")
+                    time.sleep(wait_time)
+                    if attempt == self.max_retries - 1:
+                        raise
+                else:
+                    raise
+            except Exception as e:
+                print(f"Request error (attempt {attempt + 1}/{self.max_retries}): {e}")
+                if attempt == self.max_retries - 1:
+                    raise
+                time.sleep(2 ** attempt)
+        
+        return None
         
     def search_company_by_name(self, company_name):
         """Search company CIK by company name"""
         try:
             # Use SEC company ticker database
             url = "https://www.sec.gov/files/company_tickers.json"
-            headers = {"User-Agent": self.user_agent}
             
-            response = requests.get(url, headers=headers)
-            response.raise_for_status()
+            response = self._make_request_with_retry(url)
+            if not response:
+                return None
             
             companies = response.json()
             

mcp_server_sse.py

@@ -15,6 +15,8 @@ import asyncio
 from datetime import datetime
 from edgar_client import EdgarDataClient
 from financial_analyzer import FinancialAnalyzer
+import time
+import sys
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -23,6 +25,11 @@ app = FastAPI(
     version="2.0.0"
 )
 
+# Server startup time for monitoring
+server_start_time = time.time()
+request_count = 0
+error_count = 0
+
 # Configure CORS for remote access
 app.add_middleware(
     CORSMiddleware,
@@ -32,6 +39,21 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Request tracking middleware
+@app.middleware("http")
+async def track_requests(request: Request, call_next):
+    global request_count, error_count
+    request_count += 1
+    
+    try:
+        response = await call_next(request)
+        if response.status_code >= 400:
+            error_count += 1
+        return response
+    except Exception as e:
+        error_count += 1
+        raise
+
 # Initialize EDGAR clients
 edgar_client = EdgarDataClient(
     user_agent="Juntao Peng Financial Report Metrics App (jtyxabc@gmail.com)"
@@ -178,7 +200,15 @@ MCP_TOOLS = [
 
 
 def execute_tool(tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
-    """Execute MCP tool and return clean JSON result"""
+    """Execute MCP tool and return clean JSON result with timeout protection"""
+    import signal
+    
+    class TimeoutError(Exception):
+        pass
+    
+    def timeout_handler(signum, frame):
+        raise TimeoutError("Tool execution timeout")
+    
     try:
         if tool_name == "search_company":
             result = edgar_client.search_company_by_name(arguments["company_name"])
@@ -408,14 +438,15 @@ async def sse_endpoint(request: Request):
         }
         yield f"data: {json.dumps(init_message)}\n\n"
         
-        # Keep connection alive
+        # Keep connection alive with shorter ping interval for better stability
         try:
             while True:
-                await asyncio.sleep(30)
+                await asyncio.sleep(15)  # Reduced from 30s to 15s for better keepalive
                 # Send ping to keep connection alive
                 ping_message = {
                     "jsonrpc": "2.0",
-                    "method": "ping"
+                    "method": "ping",
+                    "timestamp": datetime.now().isoformat()
                 }
                 yield f"data: {json.dumps(ping_message)}\n\n"
         except asyncio.CancelledError:
@@ -425,9 +456,10 @@ async def sse_endpoint(request: Request):
         event_stream(),
         media_type="text/event-stream",
         headers={
-            "Cache-Control": "no-cache",
+            "Cache-Control": "no-cache, no-transform",
             "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"
+            "X-Accel-Buffering": "no",
+            "Content-Type": "text/event-stream"
         }
     )
 
@@ -582,17 +614,36 @@ async def list_tools():
 
 @app.get("/health")
 async def health_check():
-    """Health check endpoint for monitoring"""
+    """Enhanced health check endpoint with diagnostics"""
+    uptime_seconds = time.time() - server_start_time
     return {
         "status": "healthy",
         "server": "sec-financial-data",
         "version": "2.0.0",
         "protocol": "MCP",
         "transport": "SSE",
-        "tools_count": len(MCP_TOOLS)
+        "tools_count": len(MCP_TOOLS),
+        "uptime_seconds": round(uptime_seconds, 2),
+        "python_version": sys.version,
+        "request_count": request_count,
+        "error_count": error_count,
+        "timestamp": datetime.now().isoformat()
     }
 
 
+@app.get("/ready")
+async def readiness_check():
+    """Readiness check for load balancers"""
+    try:
+        # Quick validation that clients are initialized
+        if edgar_client and financial_analyzer:
+            return {"status": "ready", "timestamp": datetime.now().isoformat()}
+        else:
+            raise HTTPException(status_code=503, detail="Services not initialized")
+    except Exception as e:
+        raise HTTPException(status_code=503, detail=f"Not ready: {str(e)}")
+
+
 @app.api_route("/api/{path:path}", methods=["GET", "POST", "PUT", "DELETE"])
 async def redirect_old_api(path: str):
     """Handle old REST API endpoints with helpful message"""