Add mount_path parameter to sse_app method

- Add mount_path parameter to sse_app method for direct path configuration
- Update run_sse_async and run methods to support mount_path parameter
- Update README.md with examples for different mounting methods
- Add tests for new parameter functionality

Author: tim-watcha

README.md

@@ -383,7 +383,7 @@ app = Starlette(
 app.router.routes.append(Host('mcp.acme.corp', app=mcp.sse_app()))
 ```
 
-When mounting multiple MCP servers under different paths, you need to configure the mount path for each server:
+When mounting multiple MCP servers under different paths, you can configure the mount path in several ways:
 
 ```python
 from starlette.applications import Starlette
@@ -394,20 +394,31 @@ from mcp.server.fastmcp import FastMCP
 github_mcp = FastMCP("GitHub API")
 browser_mcp = FastMCP("Browser")
 curl_mcp = FastMCP("Curl")
+search_mcp = FastMCP("Search")
 
-# Configure mount paths for each server
+# Method 1: Configure mount paths via settings (recommended for persistent configuration)
 github_mcp.settings.mount_path = "/github"
 browser_mcp.settings.mount_path = "/browser"
-curl_mcp.settings.mount_path = "/curl"
+
+# Method 2: Pass mount path directly to sse_app (preferred for ad-hoc mounting)
+# This approach doesn't modify the server's settings permanently
 
 # Create Starlette app with multiple mounted servers
 app = Starlette(
     routes=[
+        # Using settings-based configuration
         Mount("/github", app=github_mcp.sse_app()),
         Mount("/browser", app=browser_mcp.sse_app()),
-        Mount("/curl", app=curl_mcp.sse_app()),
+        
+        # Using direct mount path parameter
+        Mount("/curl", app=curl_mcp.sse_app("/curl")),
+        Mount("/search", app=search_mcp.sse_app("/search")),
     ]
 )
+
+# Method 3: For direct execution, you can also pass the mount path to run()
+if __name__ == "__main__":
+    search_mcp.run(transport="sse", mount_path="/search")
 ```
 
 For more information on mounting applications in Starlette, see the [Starlette documentation](https://www.starlette.io/routing/#submounting-routes).

src/mcp/server/fastmcp/server.py

@@ -144,11 +144,14 @@ def name(self) -> str:
     def instructions(self) -> str | None:
         return self._mcp_server.instructions
 
-    def run(self, transport: Literal["stdio", "sse"] = "stdio") -> None:
+    def run(
+        self, transport: Literal["stdio", "sse"] = "stdio", mount_path: str = ""
+    ) -> None:
         """Run the FastMCP server. Note this is a synchronous function.
 
         Args:
             transport: Transport protocol to use ("stdio" or "sse")
+            mount_path: Optional mount path for SSE transport
         """
         TRANSPORTS = Literal["stdio", "sse"]
         if transport not in TRANSPORTS.__args__:  # type: ignore
@@ -157,7 +160,7 @@ def run(self, transport: Literal["stdio", "sse"] = "stdio") -> None:
         if transport == "stdio":
             anyio.run(self.run_stdio_async)
         else:  # transport == "sse"
-            anyio.run(self.run_sse_async)
+            anyio.run(lambda: self.run_sse_async(mount_path))
 
     def _setup_handlers(self) -> None:
         """Set up core MCP protocol handlers."""
@@ -463,11 +466,11 @@ async def run_stdio_async(self) -> None:
                 self._mcp_server.create_initialization_options(),
             )
 
-    async def run_sse_async(self) -> None:
+    async def run_sse_async(self, mount_path: str = "") -> None:
         """Run the server using SSE transport."""
         import uvicorn
 
-        starlette_app = self.sse_app()
+        starlette_app = self.sse_app(mount_path)
 
         config = uvicorn.Config(
             starlette_app,
@@ -504,8 +507,11 @@ def _normalize_path(self, mount_path: str, endpoint: str) -> str:
         # Combine paths
         return mount_path + endpoint
 
-    def sse_app(self) -> Starlette:
+    def sse_app(self, mount_path: str = "") -> Starlette:
         """Return an instance of the SSE server app."""
+        # Update mount_path in settings if provided
+        if mount_path:
+            self.settings.mount_path = mount_path
         # Create normalized endpoint considering the mount path
         normalized_endpoint = self._normalize_path(
             self.settings.mount_path, self.settings.message_path

tests/server/fastmcp/test_server.py

@@ -65,7 +65,7 @@ async def test_sse_app_with_mount_path(self):
             # Verify _normalize_path was called with correct args
             mock_normalize.assert_called_once_with("/", "/messages/")
 
-        # Test with custom mount path
+        # Test with custom mount path in settings
         mcp = FastMCP()
         mcp.settings.mount_path = "/custom"
         with patch.object(
@@ -74,10 +74,20 @@ async def test_sse_app_with_mount_path(self):
             mcp.sse_app()
             # Verify _normalize_path was called with correct args
             mock_normalize.assert_called_once_with("/custom", "/messages/")
+            
+        # Test with mount_path parameter
+        mcp = FastMCP()
+        with patch.object(
+            mcp, "_normalize_path", return_value="/param/messages/"
+        ) as mock_normalize:
+            mcp.sse_app(mount_path="/param")
+            # Verify _normalize_path was called with correct args
+            mock_normalize.assert_called_once_with("/param", "/messages/")
 
     @pytest.mark.anyio
     async def test_starlette_routes_with_mount_path(self):
         """Test that Starlette routes are correctly configured with mount path."""
+        # Test with mount path in settings
         mcp = FastMCP()
         mcp.settings.mount_path = "/api"
         app = mcp.sse_app()
@@ -95,6 +105,24 @@ async def test_starlette_routes_with_mount_path(self):
         assert (
             mount_routes[0].path == "/messages"
         ), "Mount route path should be /messages"
+        
+        # Test with mount path as parameter
+        mcp = FastMCP()
+        app = mcp.sse_app(mount_path="/param")
+        
+        # Find routes by type
+        sse_routes = [r for r in app.routes if isinstance(r, Route)]
+        mount_routes = [r for r in app.routes if isinstance(r, Mount)]
+        
+        # Verify routes exist
+        assert len(sse_routes) == 1, "Should have one SSE route"
+        assert len(mount_routes) == 1, "Should have one mount route"
+        
+        # Verify path values
+        assert sse_routes[0].path == "/sse", "SSE route path should be /sse"
+        assert (
+            mount_routes[0].path == "/messages"
+        ), "Mount route path should be /messages"
 
     @pytest.mark.anyio
     async def test_non_ascii_description(self):