Upload 3 files

Dockerfile

@@ -22,10 +22,12 @@ EXPOSE 7860
 # Set environment variables for production
 ENV PYTHONUNBUFFERED=1
 ENV PYTHONDONTWRITEBYTECODE=1
+ENV REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+ENV CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
 
-# Health check for container monitoring
-HEALTHCHECK --interval=60s --timeout=15s --start-period=60s --retries=5 \
+# Health check for container monitoring - relaxed for stability
+HEALTHCHECK --interval=90s --timeout=20s --start-period=90s --retries=5 \
     CMD curl -f http://localhost:7860/health || exit 1
 
-# 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"]
+# Run MCP Server with SSE transport - optimized for stability
+CMD ["uvicorn", "mcp_server_sse:app", "--host", "0.0.0.0", "--port", "7860", "--timeout-keep-alive", "180", "--timeout-graceful-shutdown", "30", "--limit-concurrency", "30", "--backlog", "50", "--log-level", "info", "--workers", "1", "--no-access-log"]

edgar_client.py

@@ -1,6 +1,8 @@
 """EDGAR API Client Module"""
 
 import requests
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
 try:
     from sec_edgar_api.EdgarClient import EdgarClient
 except ImportError:
@@ -8,6 +10,7 @@ except ImportError:
 import json
 import time
 from functools import wraps
+import threading
 
 
 class EdgarDataClient:
@@ -18,6 +21,30 @@ class EdgarDataClient:
         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
+        self._lock = threading.Lock()  # Thread-safe rate limiting
+        
+        # Configure requests session with connection pooling and retry logic
+        self.session = requests.Session()
+        retry_strategy = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["HEAD", "GET", "OPTIONS"]
+        )
+        adapter = HTTPAdapter(
+            max_retries=retry_strategy,
+            pool_connections=10,
+            pool_maxsize=20,
+            pool_block=False
+        )
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        self.session.headers.update({"User-Agent": user_agent})
+        
+        # Cache for frequently accessed data
+        self._company_cache = {}  # Cache company info to avoid repeated calls
+        self._cache_ttl = 300  # 5 minutes cache TTL
+        self._cache_timestamps = {}
         
         if EdgarClient:
             self.edgar = EdgarClient(user_agent=user_agent)
@@ -25,17 +52,36 @@ class EdgarDataClient:
             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()
+        """Thread-safe rate limiting to comply with SEC API limits (10 requests/second)"""
+        with self._lock:
+            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):
+    def _is_cache_valid(self, cache_key):
+        """Check if cache entry is still valid"""
+        if cache_key not in self._cache_timestamps:
+            return False
+        age = time.time() - self._cache_timestamps[cache_key]
+        return age < self._cache_ttl
+    
+    def _get_cached(self, cache_key):
+        """Get cached data if valid"""
+        if self._is_cache_valid(cache_key):
+            return self._company_cache.get(cache_key)
+        return None
+    
+    def _set_cache(self, cache_key, data):
+        """Set cache data with timestamp"""
+        self._company_cache[cache_key] = data
+        self._cache_timestamps[cache_key] = time.time()
+    
+    def _make_request_with_retry(self, url, headers=None, use_session=True):
         """Make HTTP request with retry logic and timeout"""
         if headers is None:
             headers = {"User-Agent": self.user_agent}
@@ -43,7 +89,10 @@ class EdgarDataClient:
         for attempt in range(self.max_retries):
             try:
                 self._rate_limit()
-                response = requests.get(url, headers=headers, timeout=self.request_timeout)
+                if use_session:
+                    response = self.session.get(url, headers=headers, timeout=self.request_timeout)
+                else:
+                    response = requests.get(url, headers=headers, timeout=self.request_timeout)
                 response.raise_for_status()
                 return response
             except requests.exceptions.Timeout:
@@ -117,7 +166,7 @@ class EdgarDataClient:
     
     def get_company_info(self, cik):
         """
-        Get basic company information
+        Get basic company information with caching
         
         Args:
             cik (str): Company CIK code
@@ -128,25 +177,51 @@ class EdgarDataClient:
         if not self.edgar:
             print("sec_edgar_api library not installed")
             return None
+        
+        # Check cache first
+        cache_key = f"info_{cik}"
+        cached = self._get_cached(cache_key)
+        if cached:
+            return cached
             
         try:
-            # Get company submissions
-            submissions = self.edgar.get_submissions(cik=cik)
+            # Add timeout wrapper for sec-edgar-api calls
+            import signal
+            
+            def timeout_handler(signum, frame):
+                raise TimeoutError("SEC API call timeout")
             
-            return {
+            # Set alarm for 30 seconds (only works on Unix-like systems)
+            try:
+                signal.signal(signal.SIGALRM, timeout_handler)
+                signal.alarm(30)
+                submissions = self.edgar.get_submissions(cik=cik)
+                signal.alarm(0)  # Cancel alarm
+            except AttributeError:
+                # Windows doesn't support SIGALRM, use direct call
+                submissions = self.edgar.get_submissions(cik=cik)
+            
+            result = {
                 "cik": cik,
                 "name": submissions.get("name", ""),
                 "tickers": submissions.get("tickers", []),
                 "sic": submissions.get("sic", ""),
                 "sic_description": submissions.get("sicDescription", "")
             }
+            
+            # Cache the result
+            self._set_cache(cache_key, result)
+            return result
+        except TimeoutError:
+            print(f"Timeout getting company info for CIK: {cik}")
+            return None
         except Exception as e:
             print(f"Error getting company info: {e}")
             return None
     
     def get_company_filings(self, cik, form_types=None):
         """
-        Get all company filing documents
+        Get all company filing documents with caching
         
         Args:
             cik (str): Company CIK code
@@ -158,50 +233,72 @@ class EdgarDataClient:
         if not self.edgar:
             print("sec_edgar_api library not installed")
             return []
-            
-        try:
-            # Get company submissions
-            submissions = self.edgar.get_submissions(cik=cik)
-            
-            # Extract filing information
-            filings = []
-            recent = submissions.get("filings", {}).get("recent", {})
-            
-            # Get data from each field
-            form_types_list = recent.get("form", [])
-            filing_dates = recent.get("filingDate", [])
-            accession_numbers = recent.get("accessionNumber", [])
-            primary_documents = recent.get("primaryDocument", [])
-            
-            # Iterate through all filings
-            for i in range(len(form_types_list)):
-                form_type = form_types_list[i]
+        
+        # Check cache first (cache all filings, filter later)
+        cache_key = f"filings_{cik}"
+        cached = self._get_cached(cache_key)
+        
+        if not cached:
+            try:
+                # Add timeout wrapper
+                import signal
                 
-                # Filter by form type if specified
-                if form_types and form_type not in form_types:
-                    continue
+                def timeout_handler(signum, frame):
+                    raise TimeoutError("SEC API call timeout")
                 
-                filing_date = filing_dates[i] if i < len(filing_dates) else ""
-                accession_number = accession_numbers[i] if i < len(accession_numbers) else ""
-                primary_document = primary_documents[i] if i < len(primary_documents) else ""
+                try:
+                    signal.signal(signal.SIGALRM, timeout_handler)
+                    signal.alarm(30)
+                    submissions = self.edgar.get_submissions(cik=cik)
+                    signal.alarm(0)
+                except AttributeError:
+                    # Windows fallback
+                    submissions = self.edgar.get_submissions(cik=cik)
                 
-                filing = {
-                    "form_type": form_type,
-                    "filing_date": filing_date,
-                    "accession_number": accession_number,
-                    "primary_document": primary_document
-                }
+                # Extract filing information
+                filings = []
+                recent = submissions.get("filings", {}).get("recent", {})
                 
-                filings.append(filing)
-            
-            return filings
-        except Exception as e:
-            print(f"Error getting company filings: {e}")
-            return []
+                # Get data from each field
+                form_types_list = recent.get("form", [])
+                filing_dates = recent.get("filingDate", [])
+                accession_numbers = recent.get("accessionNumber", [])
+                primary_documents = recent.get("primaryDocument", [])
+                
+                # Iterate through all filings
+                for i in range(len(form_types_list)):
+                    filing_date = filing_dates[i] if i < len(filing_dates) else ""
+                    accession_number = accession_numbers[i] if i < len(accession_numbers) else ""
+                    primary_document = primary_documents[i] if i < len(primary_documents) else ""
+                    
+                    filing = {
+                        "form_type": form_types_list[i],
+                        "filing_date": filing_date,
+                        "accession_number": accession_number,
+                        "primary_document": primary_document
+                    }
+                    
+                    filings.append(filing)
+                
+                # Cache all filings
+                self._set_cache(cache_key, filings)
+                cached = filings
+                
+            except TimeoutError:
+                print(f"Timeout getting company filings for CIK: {cik}")
+                return []
+            except Exception as e:
+                print(f"Error getting company filings: {e}")
+                return []
+        
+        # Filter by form type if specified
+        if form_types:
+            return [f for f in cached if f.get("form_type") in form_types]
+        return cached
     
     def get_company_facts(self, cik):
         """
-        Get all company financial facts data
+        Get all company financial facts data with caching and timeout
         
         Args:
             cik (str): Company CIK code
@@ -212,10 +309,35 @@ class EdgarDataClient:
         if not self.edgar:
             print("sec_edgar_api library not installed")
             return {}
+        
+        # Check cache first
+        cache_key = f"facts_{cik}"
+        cached = self._get_cached(cache_key)
+        if cached:
+            return cached
             
         try:
-            facts = self.edgar.get_company_facts(cik=cik)
+            # Add timeout wrapper
+            import signal
+            
+            def timeout_handler(signum, frame):
+                raise TimeoutError("SEC API call timeout")
+            
+            try:
+                signal.signal(signal.SIGALRM, timeout_handler)
+                signal.alarm(45)  # 45 seconds for facts (larger dataset)
+                facts = self.edgar.get_company_facts(cik=cik)
+                signal.alarm(0)
+            except AttributeError:
+                # Windows fallback
+                facts = self.edgar.get_company_facts(cik=cik)
+            
+            # Cache the result
+            self._set_cache(cache_key, facts)
             return facts
+        except TimeoutError:
+            print(f"Timeout getting company facts for CIK: {cik}")
+            return {}
         except Exception as e:
             print(f"Error getting company facts: {e}")
             return {}

mcp_server_sse.py

@@ -17,12 +17,14 @@ from edgar_client import EdgarDataClient
 from financial_analyzer import FinancialAnalyzer
 import time
 import sys
+import signal
+from contextlib import contextmanager
 
 # Initialize FastAPI app
 app = FastAPI(
     title="SEC Financial Report MCP Server",
     description="Model Context Protocol Server for SEC EDGAR Financial Data",
-    version="2.2.0"
+    version="2.2.1"
 )
 
 # Server startup time for monitoring
@@ -39,19 +41,32 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Request tracking middleware
+# Request tracking middleware with timeout protection
 @app.middleware("http")
 async def track_requests(request: Request, call_next):
     global request_count, error_count
     request_count += 1
+    start_time = time.time()
     
     try:
-        response = await call_next(request)
+        # Set a timeout for the entire request
+        response = await asyncio.wait_for(
+            call_next(request),
+            timeout=120.0  # 2 minutes total timeout
+        )
         if response.status_code >= 400:
             error_count += 1
         return response
+    except asyncio.TimeoutError:
+        error_count += 1
+        print(f"Request timeout after {time.time() - start_time:.2f}s: {request.url.path}")
+        return JSONResponse(
+            status_code=504,
+            content={"error": "Request timeout", "message": "The request took too long to process"}
+        )
     except Exception as e:
         error_count += 1
+        print(f"Request error: {e}")
         raise
 
 # Initialize EDGAR clients
@@ -199,149 +214,163 @@ MCP_TOOLS = [
 ]
 
 
-def execute_tool(tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
-    """Execute MCP tool and return clean JSON result with timeout protection"""
-    import signal
-    
-    class TimeoutError(Exception):
-        pass
-    
+@contextmanager
+def timeout_context(seconds):
+    """Context manager for timeout on Unix-like systems"""
     def timeout_handler(signum, frame):
-        raise TimeoutError("Tool execution timeout")
+        raise TimeoutError(f"Operation timeout after {seconds} seconds")
     
+    # Only works on Unix-like systems
     try:
-        if tool_name == "search_company":
-            result = edgar_client.search_company_by_name(arguments["company_name"])
-            if result:
-                return {
-                    "type": "text",
-                    "text": json.dumps(result, ensure_ascii=False)
-                }
-            else:
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": f"No company found with name: {arguments['company_name']}"
-                    }, ensure_ascii=False)
-                }
-        
-        elif tool_name == "get_company_info":
-            result = edgar_client.get_company_info(arguments["cik"])
-            if result:
-                return {
-                    "type": "text",
-                    "text": json.dumps(result, ensure_ascii=False)
-                }
-            else:
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": f"No company found with CIK: {arguments['cik']}"
-                    }, ensure_ascii=False)
-                }
-        
-        elif tool_name == "get_company_filings":
-            form_types = arguments.get("form_types")
-            result = edgar_client.get_company_filings(arguments["cik"], form_types)
-            if result:
-                # Limit to 20 results
-                limited_result = result[:20]
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "total": len(result),
-                        "returned": len(limited_result),
-                        "filings": limited_result
-                    }, ensure_ascii=False)
-                }
-            else:
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": f"No filings found for CIK: {arguments['cik']}"
-                    }, ensure_ascii=False)
-                }
-        
-        elif tool_name == "get_financial_data":
-            result = edgar_client.get_financial_data_for_period(arguments["cik"], arguments["period"])
-            if result and "period" in result:
-                return {
-                    "type": "text",
-                    "text": json.dumps(result, ensure_ascii=False)
-                }
-            else:
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": f"No financial data found for CIK: {arguments['cik']}, Period: {arguments['period']}"
-                    }, ensure_ascii=False)
-                }
-        
-        elif tool_name == "extract_financial_metrics":
-            years = arguments.get("years", 3)
-            if years < 1 or years > 10:
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": "Years parameter must be between 1 and 10"
-                    }, ensure_ascii=False)
-                }
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(seconds)
+        try:
+            yield
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, old_handler)
+    except (AttributeError, ValueError):
+        # Windows or signal not available
+        yield
+
+
+def execute_tool(tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute MCP tool and return clean JSON result with enhanced timeout protection"""
+    try:
+        # Use context manager for timeout (60 seconds per tool)
+        with timeout_context(60):
+            if tool_name == "search_company":
+                result = edgar_client.search_company_by_name(arguments["company_name"])
+                if result:
+                    return {
+                        "type": "text",
+                        "text": json.dumps(result, ensure_ascii=False)
+                    }
+                else:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": f"No company found with name: {arguments['company_name']}"
+                        }, ensure_ascii=False)
+                    }
             
-            metrics = financial_analyzer.extract_financial_metrics(arguments["cik"], years)
-            if metrics:
-                formatted = financial_analyzer.format_financial_data(metrics)
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "periods": len(formatted),
-                        "data": formatted
-                    }, ensure_ascii=False)
-                }
-            else:
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": f"No financial metrics found for CIK: {arguments['cik']}"
-                    }, ensure_ascii=False)
-                }
-        
-        elif tool_name == "get_latest_financial_data":
-            result = financial_analyzer.get_latest_financial_data(arguments["cik"])
-            if result and "period" in result:
+            elif tool_name == "get_company_info":
+                result = edgar_client.get_company_info(arguments["cik"])
+                if result:
+                    return {
+                        "type": "text",
+                        "text": json.dumps(result, ensure_ascii=False)
+                    }
+                else:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": f"No company found with CIK: {arguments['cik']}"
+                        }, ensure_ascii=False)
+                    }
+            
+            elif tool_name == "get_company_filings":
+                form_types = arguments.get("form_types")
+                result = edgar_client.get_company_filings(arguments["cik"], form_types)
+                if result:
+                    # Limit to 20 results
+                    limited_result = result[:20]
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "total": len(result),
+                            "returned": len(limited_result),
+                            "filings": limited_result
+                        }, ensure_ascii=False)
+                    }
+                else:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": f"No filings found for CIK: {arguments['cik']}"
+                        }, ensure_ascii=False)
+                    }
+            
+            elif tool_name == "get_financial_data":
+                result = edgar_client.get_financial_data_for_period(arguments["cik"], arguments["period"])
+                if result and "period" in result:
+                    return {
+                        "type": "text",
+                        "text": json.dumps(result, ensure_ascii=False)
+                    }
+                else:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": f"No financial data found for CIK: {arguments['cik']}, Period: {arguments['period']}"
+                        }, ensure_ascii=False)
+                    }
+            
+            elif tool_name == "extract_financial_metrics":
+                years = arguments.get("years", 3)
+                if years < 1 or years > 10:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": "Years parameter must be between 1 and 10"
+                        }, ensure_ascii=False)
+                    }
+                
+                metrics = financial_analyzer.extract_financial_metrics(arguments["cik"], years)
+                if metrics:
+                    formatted = financial_analyzer.format_financial_data(metrics)
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "periods": len(formatted),
+                            "data": formatted
+                        }, ensure_ascii=False)
+                    }
+                else:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": f"No financial metrics found for CIK: {arguments['cik']}"
+                        }, ensure_ascii=False)
+                    }
+            
+            elif tool_name == "get_latest_financial_data":
+                result = financial_analyzer.get_latest_financial_data(arguments["cik"])
+                if result and "period" in result:
+                    return {
+                        "type": "text",
+                        "text": json.dumps(result, ensure_ascii=False)
+                    }
+                else:
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": f"No latest financial data found for CIK: {arguments['cik']}"
+                        }, ensure_ascii=False)
+                    }
+            
+            elif tool_name == "advanced_search_company" or tool_name == "advanced_search":
+                # Support both names for backward compatibility
+                result = financial_analyzer.search_company(arguments["company_input"])
+                if result.get("error"):
+                    return {
+                        "type": "text",
+                        "text": json.dumps({
+                            "error": result["error"]
+                        }, ensure_ascii=False)
+                    }
                 return {
                     "type": "text",
                     "text": json.dumps(result, ensure_ascii=False)
                 }
+            
             else:
                 return {
                     "type": "text",
                     "text": json.dumps({
-                        "error": f"No latest financial data found for CIK: {arguments['cik']}"
-                    }, ensure_ascii=False)
-                }
-        
-        elif tool_name == "advanced_search_company" or tool_name == "advanced_search":
-            # Support both names for backward compatibility
-            result = financial_analyzer.search_company(arguments["company_input"])
-            if result.get("error"):
-                return {
-                    "type": "text",
-                    "text": json.dumps({
-                        "error": result["error"]
+                        "error": f"Unknown tool: {tool_name}"
                     }, ensure_ascii=False)
                 }
-            return {
-                "type": "text",
-                "text": json.dumps(result, ensure_ascii=False)
-            }
-        
-        else:
-            return {
-                "type": "text",
-                "text": json.dumps({
-                    "error": f"Unknown tool: {tool_name}"
-                }, ensure_ascii=False)
-            }
     
     except Exception as e:
         return {
@@ -374,7 +403,7 @@ async def handle_mcp_message(request: MCPRequest):
                 },
                 "serverInfo": {
                     "name": "sec-financial-data",
-                    "version": "2.2.0"
+                    "version": "2.2.1"
                 }
             }
         ).dict()
@@ -438,10 +467,10 @@ async def sse_endpoint(request: Request):
         }
         yield f"data: {json.dumps(init_message)}\n\n"
         
-        # Keep connection alive with shorter ping interval for better stability
+        # Keep connection alive with optimized ping interval
         try:
             while True:
-                await asyncio.sleep(15)  # Reduced from 30s to 15s for better keepalive
+                await asyncio.sleep(20)  # 20 seconds ping interval for stability
                 # Send ping to keep connection alive
                 ping_message = {
                     "jsonrpc": "2.0",
@@ -1023,7 +1052,7 @@ async def health_check():
     return {
         "status": "healthy",
         "server": "sec-financial-data",
-        "version": "2.2.0",
+        "version": "2.2.1",
         "protocol": "MCP",
         "transport": "SSE",
         "tools_count": len(MCP_TOOLS),
@@ -1031,6 +1060,7 @@ async def health_check():
         "python_version": sys.version,
         "request_count": request_count,
         "error_count": error_count,
+        "error_rate": round(error_count / max(request_count, 1) * 100, 2),
         "timestamp": datetime.now().isoformat()
     }