mseep-fastapi-mcp-sse 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

app.py

@@ -0,0 +1,57 @@
+from fastapi import FastAPI, Request
+from mcp.server.sse import SseServerTransport
+from starlette.routing import Mount
+from weather import mcp
+
+# Create FastAPI application with metadata
+app = FastAPI(
+    title="FastAPI MCP SSE",
+    description="A demonstration of Server-Sent Events with Model Context "
+    "Protocol integration",
+    version="0.1.0",
+)
+
+# Create SSE transport instance for handling server-sent events
+sse = SseServerTransport("/messages/")
+
+# Mount the /messages path to handle SSE message posting
+app.router.routes.append(Mount("/messages", app=sse.handle_post_message))
+
+
+# Add documentation for the /messages endpoint
+@app.get("/messages", tags=["MCP"], include_in_schema=True)
+def messages_docs():
+    """
+    Messages endpoint for SSE communication
+
+    This endpoint is used for posting messages to SSE clients.
+    Note: This route is for documentation purposes only.
+    The actual implementation is handled by the SSE transport.
+    """
+    pass  # This is just for documentation, the actual handler is mounted above
+
+
+@app.get("/sse", tags=["MCP"])
+async def handle_sse(request: Request):
+    """
+    SSE endpoint that connects to the MCP server
+
+    This endpoint establishes a Server-Sent Events connection with the client
+    and forwards communication to the Model Context Protocol server.
+    """
+    # Use sse.connect_sse to establish an SSE connection with the MCP server
+    async with sse.connect_sse(request.scope, request.receive, request._send) as (
+        read_stream,
+        write_stream,
+    ):
+        # Run the MCP server with the established streams
+        await mcp._mcp_server.run(
+            read_stream,
+            write_stream,
+            mcp._mcp_server.create_initialization_options(),
+        )
+
+
+# Import routes at the end to avoid circular imports
+# This ensures all routes are registered to the app
+import routes  # noqa

mseep_fastapi_mcp_sse-0.1.3.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: mseep-fastapi-mcp-sse
+Version: 0.1.3
+Summary: A working example to create a FastAPI server with SSE-based MCP support
+Author-email: mseep <support@skydeck.ai>
+Requires-Python: >=3.13
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.11
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mcp[cli]>=1.3.0
+Requires-Dist: unicorn>=2.1.3
+Dynamic: license-file
+
+Package managed by MseeP.ai

mseep_fastapi_mcp_sse-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+app.py,sha256=fMeFF-d12bqR74Tk3kIXkUgGeXK8ArLDSNaIB6qtObg,1888
+routes.py,sha256=TCpBJgXnsRjLoj9KVx54mMJ-fyDpv46jlt8SIUS1k98,1119
+server.py,sha256=qIYfgFLHMId2vw0j0tnpOEFncZABuNV2-WjCZAUQFh0,318
+weather.py,sha256=L7ObmiVZO0jmlUmsCAnA7cjFt-gzJe7w9NibSiNyzHI,2942
+mseep_fastapi_mcp_sse-0.1.3.dist-info/licenses/LICENSE,sha256=3jx_ovGaWR_Y9wL1s0njbZj7IyL5klS_5VvxO9EGbiE,1065
+mseep_fastapi_mcp_sse-0.1.3.dist-info/METADATA,sha256=spERKmuqErrAtlLFisfO-GYqErW_qdlFoGRqPn3NnMc,444
+mseep_fastapi_mcp_sse-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mseep_fastapi_mcp_sse-0.1.3.dist-info/entry_points.txt,sha256=lWiP8hdv1rciwJn9kTxOBAVugY9fgMmwBgBVvp79EVg,37
+mseep_fastapi_mcp_sse-0.1.3.dist-info/top_level.txt,sha256=xpnmJRuceitZrR4gZafC8URF4ChnCe3hSmHapNAlox8,26
+mseep_fastapi_mcp_sse-0.1.3.dist-info/RECORD,,

{mseep_fastapi_mcp_sse-0.1.1.dist-info → mseep_fastapi_mcp_sse-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

mseep_fastapi_mcp_sse-0.1.3.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+app
+routes
+server
+weather

routes.py

@@ -0,0 +1,40 @@
+from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse
+from fastapi import APIRouter
+from app import app
+
+# Create a router with a general tag for API documentation organization
+router = APIRouter(tags=["General"])
+
+
+@router.get("/")
+async def homepage():
+    """Root endpoint that returns a simple HTML welcome page"""
+    html_content = (
+        "<h1>FastAPI MCP SSE</h1>"
+        "<p>Welcome to the SSE demo with MCP integration.</p>"
+    )
+    return HTMLResponse(html_content)
+
+
+@router.get("/about")
+async def about():
+    """About endpoint that returns information about the application"""
+    return PlainTextResponse(
+        "About FastAPI MCP SSE: A demonstration of Server-Sent Events "
+        "with Model Context Protocol integration."
+    )
+
+
+@router.get("/status")
+async def status():
+    """Status endpoint that returns the current server status"""
+    status_info = {
+        "status": "running",
+        "server": "FastAPI MCP SSE",
+        "version": "0.1.0",
+    }
+    return JSONResponse(status_info)
+
+
+# Include the router in the main application
+app.include_router(router)

server.py

@@ -0,0 +1,16 @@
+import uvicorn
+import os
+from app import app
+
+# Environment variable configuration
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", "8000"))
+
+
+def run():
+    """Start the FastAPI server with uvicorn"""
+    uvicorn.run(app, host=HOST, port=PORT, log_level="info")
+
+
+if __name__ == "__main__":
+    run()

weather.py

@@ -0,0 +1,96 @@
+from typing import Any
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+# Initialize FastMCP server
+mcp = FastMCP("weather")
+
+# Constants
+NWS_API_BASE = "https://api.weather.gov"
+USER_AGENT = "weather-app/1.0"
+
+
+async def make_nws_request(url: str) -> dict[str, Any] | None:
+    """Make a request to the NWS API with proper error handling."""
+    headers = {"User-Agent": USER_AGENT, "Accept": "application/geo+json"}
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            return response.json()
+        except Exception:
+            return None
+
+
+def format_alert(feature: dict) -> str:
+    """Format an alert feature into a readable string."""
+    props = feature["properties"]
+    return f"""
+Event: {props.get('event', 'Unknown')}
+Area: {props.get('areaDesc', 'Unknown')}
+Severity: {props.get('severity', 'Unknown')}
+Description: {props.get('description', 'No description available')}
+Instructions: {props.get('instruction', 'No specific instructions provided')}
+"""
+
+
+@mcp.tool()
+async def get_alerts(state: str) -> str:
+    """Get weather alerts for a US state.
+
+    Args:
+        state: Two-letter US state code (e.g. CA, NY)
+    """
+    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
+    data = await make_nws_request(url)
+
+    if not data or "features" not in data:
+        return "Unable to fetch alerts or no alerts found."
+
+    if not data["features"]:
+        return "No active alerts for this state."
+
+    alerts = [format_alert(feature) for feature in data["features"]]
+    return "\n---\n".join(alerts)
+
+
+@mcp.tool()
+async def get_forecast(latitude: float, longitude: float) -> str:
+    """Get weather forecast for a location.
+
+    Args:
+        latitude: Latitude of the location
+        longitude: Longitude of the location
+    """
+    # First get the forecast grid endpoint
+    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
+    points_data = await make_nws_request(points_url)
+
+    if not points_data:
+        return "Unable to fetch forecast data for this location."
+
+    # Get the forecast URL from the points response
+    forecast_url = points_data["properties"]["forecast"]
+    forecast_data = await make_nws_request(forecast_url)
+
+    if not forecast_data:
+        return "Unable to fetch detailed forecast."
+
+    # Format the periods into a readable forecast
+    periods = forecast_data["properties"]["periods"]
+    forecasts = []
+    for period in periods[:5]:  # Only show next 5 periods
+        forecast = f"""
+{period['name']}:
+Temperature: {period['temperature']}°{period['temperatureUnit']}
+Wind: {period['windSpeed']} {period['windDirection']}
+Forecast: {period['detailedForecast']}
+"""
+        forecasts.append(forecast)
+
+    return "\n---\n".join(forecasts)
+
+
+if __name__ == "__main__":
+    # Initialize and run the server
+    mcp.run(transport="sse")

mseep_fastapi_mcp_sse-0.1.1.dist-info/METADATA

@@ -1,200 +0,0 @@
-Metadata-Version: 2.4
-Name: mseep-fastapi-mcp-sse
-Version: 0.1.1
-Summary: A working example to create a FastAPI server with SSE-based MCP support
-Home-page: 
-Author: mseep
-Author-email: mseep <support@skydeck.ai>
-Maintainer-email: mseep <support@skydeck.ai>
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi>=0.115.11
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: mcp[cli]>=1.3.0
-Requires-Dist: unicorn>=2.1.3
-Dynamic: author
-Dynamic: license-file
-Dynamic: requires-python
-
-# FastAPI MCP SSE
-
-<p align="center">
-  <strong>English</strong> | <a href="/README.zh-CN.md">简体中文</a>
-</p>
-
-A Server-Sent Events (SSE) implementation using FastAPI framework with [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) integration.
-
-## What is MCP?
-
-The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) is an open standard that enables AI models to interact with external tools and data sources. MCP solves several key challenges in AI development:
-
-- **Context limitations**: Allows models to access up-to-date information beyond their training data
-- **Tool integration**: Provides a standardized way for models to use external tools and APIs
-- **Interoperability**: Creates a common interface between different AI models and tools
-- **Extensibility**: Makes it easy to add new capabilities to AI systems without retraining
-
-This project demonstrates how to implement MCP using Server-Sent Events (SSE) in a FastAPI web application.
-
-## Description
-
-This project demonstrates how to implement Server-Sent Events (SSE) using the FastAPI framework while integrating Model Context Protocol (MCP) functionality. The key feature is the seamless integration of MCP's SSE capabilities within a full-featured FastAPI web application that includes custom routes.
-
-## Features
-
-- Server-Sent Events (SSE) implementation with MCP
-- FastAPI framework integration with custom routes
-- Unified web application with both MCP and standard web endpoints
-- Customizable route structure
-- Clean separation of concerns between MCP and web functionality
-
-## Architecture
-
-This project showcases a modular architecture that:
-
-1. Integrates MCP SSE endpoints (`/sse` and `/messages/`) into a FastAPI application
-2. Provides standard web routes (`/`, `/about`, `/status`, `/docs`, `/redoc`)
-3. Demonstrates how to maintain separation between MCP functionality and web routes
-
-## Installation & Usage Options
-
-### Prerequisites
-
-Install [UV Package Manager](https://docs.astral.sh/uv/) - A fast Python package installer written in Rust:
-
-```cmd
-powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
-```
-
-### Option 1: Quick Run Without Installation
-
-Run the application directly without cloning the repository using UV's execution tool:
-
-```cmd
-uvx --from git+https://github.com/panz2018/fastapi_mcp_sse.git start
-```
-
-### Option 2: Full Installation
-
-#### Create Virtual Environment
-
-Create an isolated Python environment for the project:
-
-```cmd
-uv venv
-```
-
-#### Activate Virtual Environment
-
-Activate the virtual environment to use it:
-
-```cmd
-.venv\Scripts\activate
-```
-
-#### Install Dependencies
-
-Install all required packages:
-
-```cmd
-uv pip install -r pyproject.toml
-```
-
-#### Start the Integrated Server
-
-Launch the integrated FastAPI server with MCP SSE functionality:
-
-```cmd
-python src/server.py
-```
-
-or
-
-```cmd
-uv run start
-```
-
-### Available Endpoints
-
-After starting the server (using either Option 1 or Option 2), the following endpoints will be available:
-
-- Main server: http://localhost:8000
-- Standard web routes:
-  - Home page: http://localhost:8000/
-  - About page: http://localhost:8000/about
-  - Status API: http://localhost:8000/status
-  - Documentation (Swagger UI): http://localhost:8000/docs
-  - Documentation (ReDoc): http://localhost:8000/redoc
-- MCP SSE endpoints:
-  - SSE endpoint: http://localhost:8000/sse
-  - Message posting: http://localhost:8000/messages/
-
-### Debug with MCP Inspector
-
-For testing and debugging MCP functionality, use the MCP Inspector:
-
-```cmd
-mcp dev ./src/weather.py
-```
-
-### Connect to MCP Inspector
-
-1. Open MCP Inspector at http://localhost:5173
-2. Configure the connection:
-   - Set Transport Type to `SSE`
-   - Enter URL: http://localhost:8000/sse
-   - Click `Connect`
-
-### Test the Functions
-
-1. Navigate to `Tools` section
-2. Click `List Tools` to see available functions:
-   - `get_alerts` : Get weather alerts
-   - `get_forcast` : Get weather forecast
-3. Select a function
-4. Enter required parameters
-5. Click `Run Tool` to execute
-
-## Extending the Application
-
-### Adding Custom Routes
-
-The application structure makes it easy to add new routes using FastAPI's APIRouter:
-
-1. Define new route handlers in routes.py using the APIRouter:
-
-   ```python
-   @router.get("/new-route")
-   async def new_route():
-       return {"message": "This is a new route"}
-   ```
-
-2. All routes defined with the router will be automatically included in the main application
-
-### Customizing MCP Integration
-
-The MCP SSE functionality is integrated in server.py through:
-
-- Creating an SSE transport
-- Setting up an SSE handler
-- Adding MCP routes to the FastAPI application
-
-## Integration with [Continue](https://www.continue.dev/)
-
-To use this MCP server with the Continue VS Code extension, add the following configuration to your Continue settings:
-
-```json
-{
-  "experimental": {
-    "modelContextProtocolServers": [
-      {
-        "transport": {
-          "name": "weather",
-          "type": "sse",
-          "url": "http://localhost:8000/sse"
-        }
-      }
-    ]
-  }
-}
-```

mseep_fastapi_mcp_sse-0.1.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-mseep_fastapi_mcp_sse-0.1.1.dist-info/licenses/LICENSE,sha256=3jx_ovGaWR_Y9wL1s0njbZj7IyL5klS_5VvxO9EGbiE,1065
-mseep_fastapi_mcp_sse-0.1.1.dist-info/METADATA,sha256=mHcfIa3My1iy44B3bgrCnOTkmM_eDtaAVMOel3pu86A,5622
-mseep_fastapi_mcp_sse-0.1.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-mseep_fastapi_mcp_sse-0.1.1.dist-info/entry_points.txt,sha256=lWiP8hdv1rciwJn9kTxOBAVugY9fgMmwBgBVvp79EVg,37
-mseep_fastapi_mcp_sse-0.1.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-mseep_fastapi_mcp_sse-0.1.1.dist-info/RECORD,,

mseep_fastapi_mcp_sse-0.1.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-