Upload 3 files

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.10-slim
+FROM python:3.10-slim
 
 WORKDIR /app
 
@@ -14,10 +14,6 @@ COPY edgar_client.py .
 COPY financial_analyzer.py .
 COPY mcp_server_fastmcp.py .
 COPY app.py .
-COPY start.sh .
-
-# Make start script executable
-RUN chmod +x start.sh
 
 # Expose port
 EXPOSE 7860
@@ -31,5 +27,5 @@ ENV HOST=0.0.0.0
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 CMD curl -f http://localhost:7860/ || exit 1
 
-# Run startup script
-CMD ["./start.sh"]
+# Run FastAPI app with integrated MCP server
+CMD ["python", "app.py"]

app.py

@@ -1,12 +1,17 @@
 """
 Simple FastAPI web interface for MCP Server usage guide
-MCP server runs separately on port 8001
+Integrated with MCP server directly
 """
 from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse, Response
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
-import httpx
+import json
+
+# Import MCP server components
+from mcp.server.fastmcp import FastMCP
+from edgar_client import EdgarDataClient
+from financial_analyzer import FinancialAnalyzer
 
 app = FastAPI(title="SEC Financial Data MCP Server")
 
@@ -19,22 +24,189 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Proxy to MCP server
+# Initialize EDGAR clients
+edgar_client = EdgarDataClient(
+    user_agent="Juntao Peng Financial Report Metrics App (jtyxabc@gmail.com)"
+)
+
+financial_analyzer = FinancialAnalyzer(
+    user_agent="Juntao Peng Financial Report Metrics App (jtyxabc@gmail.com)"
+)
+
+# Create FastMCP server with pure JSON response
+mcp = FastMCP("sec-financial-data", json_response=True)
+
+
+@mcp.tool()
+def search_company(company_name: str) -> dict:
+    """Search for a company by name in SEC EDGAR database."""
+    result = edgar_client.search_company_by_name(company_name)
+    if result:
+        return result
+    else:
+        return {"error": f"No company found with name: {company_name}"}
+
+
+@mcp.tool()
+def get_company_info(cik: str) -> dict:
+    """Get detailed company information."""
+    result = edgar_client.get_company_info(cik)
+    if result:
+        return result
+    else:
+        return {"error": f"No company found with CIK: {cik}"}
+
+
+@mcp.tool()
+def get_company_filings(cik: str, form_types: list[str] | None = None) -> dict:
+    """Get list of company SEC filings."""
+    # Convert list to tuple for caching
+    if form_types:
+        form_types_tuple = tuple(form_types)
+    else:
+        form_types_tuple = None
+    
+    result = edgar_client.get_company_filings(cik, form_types_tuple)
+    if result:
+        limited_result = result[:20]
+        return {
+            "total": len(result),
+            "returned": len(limited_result),
+            "filings": limited_result
+        }
+    else:
+        return {"error": f"No filings found for CIK: {cik}"}
+
+
+@mcp.tool()
+def get_financial_data(cik: str, period: str) -> dict:
+    """Get financial data for a specific period."""
+    result = edgar_client.get_financial_data_for_period(cik, period)
+    if result and "period" in result:
+        return result
+    else:
+        return {"error": f"No financial data found for CIK: {cik}, Period: {period}"}
+
+
+@mcp.tool()
+def extract_financial_metrics(cik: str, years: int = 3) -> dict:
+    """Extract comprehensive financial metrics for multiple years."""
+    if years < 1 or years > 10:
+        return {"error": "Years parameter must be between 1 and 10"}
+    
+    metrics = financial_analyzer.extract_financial_metrics(cik, years)
+    
+    if metrics:
+        formatted = financial_analyzer.format_financial_data(metrics)
+        return {
+            "periods": len(formatted),
+            "data": formatted
+        }
+    else:
+        return {"error": f"No financial metrics extracted for CIK: {cik}"}
+
+
+@mcp.tool()
+def get_latest_financial_data(cik: str) -> dict:
+    """Get the most recent financial data available."""
+    result = financial_analyzer.get_latest_financial_data(cik)
+    if result and "period" in result:
+        return result
+    else:
+        return {"error": f"No latest financial data found for CIK: {cik}"}
+
+
+@mcp.tool()
+def advanced_search_company(company_input: str) -> dict:
+    """Advanced search supporting both company name and CIK code."""
+    result = financial_analyzer.search_company(company_input)
+    if result.get("error"):
+        return {"error": result["error"]}
+    return result
+
+
+# Mount MCP server SSE endpoint
 @app.post("/sse")
-async def proxy_to_mcp(request: Request):
-    """Proxy SSE requests to MCP server on port 8001"""
+@app.get("/sse")
+async def mcp_sse_endpoint(request: Request):
+    """MCP SSE endpoint - handle both GET and POST"""
     try:
-        body = await request.json()
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(
-                "http://127.0.0.1:8001/sse",
-                json=body,
-                headers={"Content-Type": "application/json"}
-            )
-            return JSONResponse(content=response.json(), status_code=response.status_code)
+        # For POST requests, get JSON body
+        if request.method == "POST":
+            body = await request.json()
+            
+            # Handle JSON-RPC request
+            if body.get("method") == "tools/list":
+                # List all tools
+                tools = []
+                for tool_name, tool_func in mcp._tool_manager._tools.items():
+                    tools.append({
+                        "name": tool_name,
+                        "description": tool_func.__doc__ or "",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {},
+                            "required": []
+                        }
+                    })
+                
+                return JSONResponse({
+                    "jsonrpc": "2.0",
+                    "id": body.get("id"),
+                    "result": {"tools": tools}
+                })
+            
+            elif body.get("method") == "tools/call":
+                # Call a specific tool
+                tool_name = body.get("params", {}).get("name")
+                arguments = body.get("params", {}).get("arguments", {})
+                
+                if tool_name in mcp._tool_manager._tools:
+                    tool_func = mcp._tool_manager._tools[tool_name]
+                    result = tool_func(**arguments)
+                    
+                    return JSONResponse({
+                        "jsonrpc": "2.0",
+                        "id": body.get("id"),
+                        "result": {
+                            "content": [{
+                                "type": "text",
+                                "text": json.dumps(result)
+                            }]
+                        }
+                    })
+                else:
+                    return JSONResponse({
+                        "jsonrpc": "2.0",
+                        "id": body.get("id"),
+                        "error": {
+                            "code": -32601,
+                            "message": f"Tool not found: {tool_name}"
+                        }
+                    })
+            
+            else:
+                return JSONResponse({
+                    "jsonrpc": "2.0",
+                    "id": body.get("id"),
+                    "error": {
+                        "code": -32601,
+                        "message": f"Method not found: {body.get('method')}"
+                    }
+                })
+        
+        else:
+            # GET request - return info
+            return JSONResponse({
+                "service": "SEC Financial Data MCP Server",
+                "protocol": "MCP 2024-11-05",
+                "transport": "SSE",
+                "status": "online"
+            })
+    
     except Exception as e:
         return JSONResponse(
-            content={"error": str(e), "type": "proxy_error"},
+            content={"error": str(e), "type": "server_error"},
             status_code=500
         )
 

requirements.txt

@@ -4,4 +4,3 @@ uvicorn[standard]>=0.30
 pydantic>=2.10.1
 sec-edgar-api==1.1.0
 requests==2.31.0
-httpx==0.27.0