mseep-fastapi-mcp-sse 0.1.2__tar.gz → 0.1.3__tar.gz

{mseep_fastapi_mcp_sse-0.1.2 → mseep_fastapi_mcp_sse-0.1.3}/PKG-INFO

@@ -1,20 +1,15 @@
 Metadata-Version: 2.4
 Name: mseep-fastapi-mcp-sse
-Version: 0.1.2
+Version: 0.1.3
 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
+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: author
 Dynamic: license-file
-Dynamic: requires-python
 
-# Package managed by MseeP.ai
+Package managed by MseeP.ai

mseep_fastapi_mcp_sse-0.1.3/README.md

@@ -0,0 +1,181 @@
+# 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.2 → mseep_fastapi_mcp_sse-0.1.3}/pyproject.toml

@@ -1,8 +1,7 @@
 [project]
 name = "mseep-fastapi-mcp-sse"
-version = "0.1.2"
+version = "0.1.3"
 description = "A working example to create a FastAPI server with SSE-based MCP support"
-readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "fastapi>=0.115.11",
@@ -13,9 +12,10 @@ dependencies = [
 authors = [
     { name = "mseep", email = "support@skydeck.ai" },
 ]
-maintainers = [
-    { name = "mseep", email = "support@skydeck.ai" },
-]
+
+[project.readme]
+content-type = "text/plain"
+text = "Package managed by MseeP.ai"
 
 [project.scripts]
 start = "server:run"

mseep_fastapi_mcp_sse-0.1.3/src/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.2 → mseep_fastapi_mcp_sse-0.1.3}/src/mseep_fastapi_mcp_sse.egg-info/PKG-INFO

@@ -1,20 +1,15 @@
 Metadata-Version: 2.4
 Name: mseep-fastapi-mcp-sse
-Version: 0.1.2
+Version: 0.1.3
 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
+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: author
 Dynamic: license-file
-Dynamic: requires-python
 
-# Package managed by MseeP.ai
+Package managed by MseeP.ai

{mseep_fastapi_mcp_sse-0.1.2 → mseep_fastapi_mcp_sse-0.1.3}/src/mseep_fastapi_mcp_sse.egg-info/SOURCES.txt

@@ -1,7 +1,10 @@
 LICENSE
 README.md
 pyproject.toml
-setup.py
+src/app.py
+src/routes.py
+src/server.py
+src/weather.py
 src/mseep_fastapi_mcp_sse.egg-info/PKG-INFO
 src/mseep_fastapi_mcp_sse.egg-info/SOURCES.txt
 src/mseep_fastapi_mcp_sse.egg-info/dependency_links.txt

mseep_fastapi_mcp_sse-0.1.3/src/mseep_fastapi_mcp_sse.egg-info/top_level.txt

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

mseep_fastapi_mcp_sse-0.1.3/src/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)

mseep_fastapi_mcp_sse-0.1.3/src/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()

mseep_fastapi_mcp_sse-0.1.3/src/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.2/README.md

@@ -1 +0,0 @@
-# Package managed by MseeP.ai

mseep_fastapi_mcp_sse-0.1.2/setup.py

@@ -1,20 +0,0 @@
-
-from setuptools import setup, find_packages
-
-setup(
-    name="mseep-fastapi-mcp-sse",
-    version="0.1.0",
-    description="A working example to create a FastAPI server with SSE-based MCP support",
-    author="mseep",
-    author_email="support@skydeck.ai",
-    url="",
-    packages=find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.6",
-    install_requires=['fastapi>=0.115.11', 'httpx>=0.28.1', 'mcp[cli]>=1.3.0', 'unicorn>=2.1.3'],
-    keywords=["mseep"] + [],
-)

mseep_fastapi_mcp_sse-0.1.2/src/mseep_fastapi_mcp_sse.egg-info/top_level.txt

@@ -1 +0,0 @@
-