Fix SSE client handling of nested path URLs

[danilpavlov]

Fix SSE client failing when connecting to servers with nested paths (e.g., http://domain/path1/path2/sse). Previously, the client worked only with simple URLs like http://domain/sse.

The fix extracts the base path segment between domain and /sse endpoint using regex, then correctly constructs the response URL by preserving the path structure. This ensures proper communication with MCP servers hosted under non-root paths.

Without this fix, clients couldn't connect to SSE servers deployed under nested paths, as the endpoint URLs for posting messages were constructed incorrectly.

Motivation and Context

I got problem while deploying my MCP server inside a Kubernetes cluster. The SSE client was only working with simple URLs like http://example-domain/sse, but failed to properly handle more complex paths such as http://example-domain/path1/path2/sse.

When the server was deployed under nested paths, the client couldn't establish a proper connection because it was incorrectly constructing the endpoint URLs for posting messages. This made it impossible to use MCP servers hosted under non-root paths, which is a common scenario in Kubernetes environments where services often run behind path-based routing.

How Has This Been Tested?

I ve tested on version for local mcp server (http://localhost:8000/sse) and with special mask (http://domain/dummy/sse)

Types of changes

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to change)
• Documentation update

Checklist

• I have read the MCP Documentation
• My code follows the repository's style guidelines
• New and existing tests pass locally
• I have added appropriate error handling
• I have added or updated documentation as needed

[ylassoued]

Thank you very much @danilpavlov!!! You saved my day with your PR. I hope it will be merged soon.

[jonathanglima]

Nice!

Just wanted to add that using this alongside langchain's adapters that use the /mcp/sse prefix made the /mcp to get repeated. I had to change it a bit to fix it. Worked on:

• http://localhost:8000/sse
• http://localhost:8000/mcp/sse
• http://localhost:8000/myversion/mcp/sse
• http://localhost:8000/myversion/sse

Please note that I also had to change the urljoin

url_parsed = urlparse(url)
base_path = re.search(
r"https?://[^/]+/(.+?)(?:/mcp)?/sse$", url
)
base_path = (
base_path.group(1) if base_path else ""
)
endpoint_url = urljoin(
url_parsed.scheme + "://" + url_parsed.netloc,
base_path + sse.data
)
logger.info(
f"Received endpoint URL: {endpoint_url}"
)

[jonathanglima]

Please see danilpavlov#1@danilpavlov

[danilpavlov]

Nice!

Just wanted to add that using this alongside langchain's adapters that use the /mcp/sse prefix made the /mcp to get repeated. I had to change it a bit to fix it. Worked on:

• http://localhost:8000/sse
• http://localhost:8000/mcp/sse
• http://localhost:8000/myversion/mcp/sse
• http://localhost:8000/myversion/sse

Please note that I also had to change the urljoin

url_parsed = urlparse(url)
base_path = re.search(
r"https?://[^/]+/(.+?)(?:/mcp)?/sse$", url
)
base_path = (
base_path.group(1) if base_path else ""
)
endpoint_url = urljoin(
url_parsed.scheme + "://" + url_parsed.netloc,
base_path + sse.data
)
logger.info(
f"Received endpoint URL: {endpoint_url}"
)

Thank you @jonathanglima so much for that feature!

[danilpavlov]

@dsp-ant Can you please check this PR. Forget to mark as reviewer :/

[sterankin]

Be good to get this merged and released

[sebin1213]

Thanks a lot for the great PR!

I have a suggestion regarding the current implementation.

Right now, the SSE client dynamically extracts the base path using regex to reconstruct the endpoint URL. While this works, it places too much responsibility on the client to figure out the correct path structure. This can lead to edge cases and inconsistent behavior—especially in environments with path-based routing like Kubernetes.

A more reliable and maintainable approach would be to have the server explicitly provide the full and correct session_uri to the client. For example, in src/mcp/server/sse.py, there's this snippet:

session_id=uuid4()
# === mount_prefix ===request_path=scope["path"] # e.g., "/test/sse"match=re.match(r"^/([^/]+(?:/mcp)?)/sse$", request_path)
mount_prefix=match.group(1) ifmatchelse""session_uri=f"/{quote(mount_prefix)}{quote(self._endpoint)}?session_id={session_id.hex}"

If the server constructs the session_uri correctly and returns it to the client, the client doesn't need to guess or reconstruct the path—it can just use what's provided.

In short, I believe the server should own the responsibility of defining the correct mount path or prefix. That way, the client logic remains simpler and more robust.

[jonathanglima]

That's nice @sebin1213 . I wasn't aware that the server could actually provide the session uri to the client. Responsibility-wise, that's much better

[danilpavlov]

Yeah, @sebin1213 that's a really good point -- the server seem to be a better place for that feature. Great job! Thank you for joining us

[rkondra-eightfold]

Hi @danilpavlov

• raised [Fix] SSE client to support MCP server mounted under a base path on a different ASGI server #524 for the same issue
• In our setup, we have existing FastAPI app, and MCP server is mounted on a subpath
• MCP server doesn't know where it was mounted
• Client needs a prefix to correct the messages endpoint

Can you please suggest?

cc: @dsp-ant

[pritam-dey3]

I just ran into this. When can we expect this to be merged? The current workarounds are really jarring, and this small fix can save a lot of work.

Thanks for all the work.

[tim-watcha]

I wanted to share some thoughts on PR #540 vs your approach:

Your regex solution is clever, but runs pattern matching on every request (performance overhead) and may struggle with certain path patterns.

PR #540's advantages:

• One-time mount_path configuration instead of regex parsing each request
• Comprehensive test coverage for various scenarios
• Reusable normalization helper
• Clear documentation with examples
• Backwards compatibility

Both approaches solve the core issue, but #540 may offer better performance and reliability in complex deployments. Appreciate your work on this!

[xorcus]

I just hit the same problem. Could you please consider allowing for the base_path to be supplied?
Example modification in python-sdk/src/mcp/server/fastmcp/server.py:

defsse_app(self, base_path: str='') ->Starlette:
"""Return an instance of the SSE server app."""sse=SseServerTransport(f'{base_path}{self.settings.message_path}')

The original code looks like this:

defsse_app(self) ->Starlette:
"""Return an instance of the SSE server app."""sse=SseServerTransport(self.settings.message_path)
asyncdefhandle_sse(request: Request) ->None:
asyncwithsse.connect_sse(
request.scope,
request.receive,
request._send, # type: ignore[reportPrivateUsage]
) asstreams:
awaitself._mcp_server.run(
streams[0],
streams[1],
self._mcp_server.create_initialization_options(),
)
returnStarlette(
debug=self.settings.debug,
routes=[
Route(self.settings.sse_path, endpoint=handle_sse),
Mount(self.settings.message_path, app=sse.handle_post_message),
],
)

Exposing the base_path as suggested would allow for mounting with Starlette as follows:

Mount('/mcp', mcp.sse_app(base_path='/mcp')),

It is a bit redundant, but it works.

[ihrpr]

Thanks @danilpavlov for this PR! We're closing this in favor of PR #540, which provides a solution using server-side mount_path configuration. Appreciate your contribution! 🙏

[thomaswetzler]

For me, this works for sse and stramable... but mount path with ".."?

from fastapi import FastAPI
from starlette.applications import Starlette
from starlette.routing import Mount
from mcp.server.fastmcp import FastMCP
import contextlib
# Create multiple MCP servers
github_mcp = FastMCP("GitHub API", mount_path="/github")
browser_mcp = FastMCP("Browser")
curl_mcp = FastMCP("Curl", mount_path="/curl")
search_mcp = FastMCP("Search")
@github_mcp.tool(description="A simple add tool")
@browser_mcp.tool(description="A simple add tool")
@curl_mcp.tool(description="A simple add tool")
@search_mcp.tool(description="A simple add tool")
def add_two(n: int) -> int:
return n + 2
# Method 1: Configure mount paths via settings (recommended for persistent configuration)
github_mcp.settings.mount_path = "/../github"
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 a combined lifespan to manage both session managers
@contextlib.asynccontextmanager
async def lifespan(app: FastAPI):
async with contextlib.AsyncExitStack() as stack:
#await stack.enter_async_context(github_mcp.session_manager.run())
#await stack.enter_async_context(browser_mcp.session_manager.run())
await stack.enter_async_context(curl_mcp.session_manager.run())
await stack.enter_async_context(search_mcp.session_manager.run())
yield
# Create Starlette app with multiple mounted servers
app = FastAPI(
lifespan=lifespan,
routes=[
# Using settings-based configuration
Mount("/github", app=github_mcp.sse_app()),
Mount("/browser", app=browser_mcp.sse_app()),
# Using direct mount path parameter
Mount("/curl", app=curl_mcp.streamable_http_app()),
Mount("/search", app=search_mcp.streamable_http_app()),
]
)