fastmcp 2.3.0rc1__py3-none-any.whl → 2.3.2__py3-none-any.whl

fastmcp/cli/cli.py

@@ -327,14 +327,14 @@ def run(
         typer.Option(
             "--transport",
             "-t",
-            help="Transport protocol to use (stdio or sse)",
+            help="Transport protocol to use (stdio, streamable-http, or sse)",
         ),
     ] = None,
     host: Annotated[
         str | None,
         typer.Option(
             "--host",
-            help="Host to bind to when using sse transport (default: 127.0.0.1)",
+            help="Host to bind to when using http transport (default: 127.0.0.1)",
         ),
     ] = None,
     port: Annotated[
@@ -342,7 +342,7 @@ def run(
         typer.Option(
             "--port",
             "-p",
-            help="Port to bind to when using sse transport (default: 8000)",
+            help="Port to bind to when using http transport (default: 8000)",
         ),
     ] = None,
     log_level: Annotated[
@@ -350,20 +350,19 @@ def run(
         typer.Option(
             "--log-level",
             "-l",
-            help="Log level for sse transport (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+            help="Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
         ),
     ] = None,
 ) -> None:
     """Run a MCP server.
 
-    The server can be specified in two ways:\n
+    The server can be specified in two ways:
     1. Module approach: server.py - runs the module directly, expecting a server.run() call.\n
     2. Import approach: server.py:app - imports and runs the specified server object.\n\n
 
     Note: This command runs the server directly. You are responsible for ensuring
-    all dependencies are available.\n
-    For dependency management, use `mcp install` or `mcp dev` instead.
-    """  # noqa: E501
+    all dependencies are available.
+    """
     file, server_object = _parse_file_path(file_spec)
 
     logger.debug(

fastmcp/low_level/README.md

@@ -0,0 +1 @@
+Patched low-level objects. When possible, we prefer the official SDK, but we patch bugs here if necessary.

fastmcp/low_level/sse_server_transport.py

@@ -0,0 +1,104 @@
+import logging
+from contextlib import asynccontextmanager
+from typing import Any
+from urllib.parse import quote
+from uuid import uuid4
+
+import anyio
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp.server.sse import SseServerTransport as LowLevelSSEServerTransport
+from mcp.shared.message import SessionMessage
+from sse_starlette import EventSourceResponse
+from starlette.types import Receive, Scope, Send
+
+logger = logging.getLogger(__name__)
+
+
+class SseServerTransport(LowLevelSSEServerTransport):
+    """
+    Patched SSE server transport
+    """
+
+    @asynccontextmanager
+    async def connect_sse(self, scope: Scope, receive: Receive, send: Send):
+        """
+        See https://github.com/modelcontextprotocol/python-sdk/pull/659/
+        """
+        if scope["type"] != "http":
+            logger.error("connect_sse received non-HTTP request")
+            raise ValueError("connect_sse can only handle HTTP requests")
+
+        logger.debug("Setting up SSE connection")
+        read_stream: MemoryObjectReceiveStream[SessionMessage | Exception]
+        read_stream_writer: MemoryObjectSendStream[SessionMessage | Exception]
+
+        write_stream: MemoryObjectSendStream[SessionMessage]
+        write_stream_reader: MemoryObjectReceiveStream[SessionMessage]
+
+        read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
+        write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
+
+        session_id = uuid4()
+        self._read_stream_writers[session_id] = read_stream_writer
+        logger.debug(f"Created new session with ID: {session_id}")
+
+        # Determine the full path for the message endpoint to be sent to the client.
+        # scope['root_path'] is the prefix where the current Starlette app
+        # instance is mounted.
+        # e.g., "" if top-level, or "/api_prefix" if mounted under "/api_prefix".
+        root_path = scope.get("root_path", "")
+
+        # self._endpoint is the path *within* this app, e.g., "/messages".
+        # Concatenating them gives the full absolute path from the server root.
+        # e.g., "" + "/messages" -> "/messages"
+        # e.g., "/api_prefix" + "/messages" -> "/api_prefix/messages"
+        full_message_path_for_client = root_path.rstrip("/") + self._endpoint
+
+        # This is the URI (path + query) the client will use to POST messages.
+        client_post_uri_data = (
+            f"{quote(full_message_path_for_client)}?session_id={session_id.hex}"
+        )
+
+        sse_stream_writer, sse_stream_reader = anyio.create_memory_object_stream[
+            dict[str, Any]
+        ](0)
+
+        async def sse_writer():
+            logger.debug("Starting SSE writer")
+            async with sse_stream_writer, write_stream_reader:
+                await sse_stream_writer.send(
+                    {"event": "endpoint", "data": client_post_uri_data}
+                )
+                logger.debug(f"Sent endpoint event: {client_post_uri_data}")
+
+                async for session_message in write_stream_reader:
+                    logger.debug(f"Sending message via SSE: {session_message}")
+                    await sse_stream_writer.send(
+                        {
+                            "event": "message",
+                            "data": session_message.message.model_dump_json(
+                                by_alias=True, exclude_none=True
+                            ),
+                        }
+                    )
+
+        async with anyio.create_task_group() as tg:
+
+            async def response_wrapper(scope: Scope, receive: Receive, send: Send):
+                """
+                The EventSourceResponse returning signals a client close / disconnect.
+                In this case we close our side of the streams to signal the client that
+                the connection has been closed.
+                """
+                await EventSourceResponse(
+                    content=sse_stream_reader, data_sender_callable=sse_writer
+                )(scope, receive, send)
+                await read_stream_writer.aclose()
+                await write_stream_reader.aclose()
+                logging.debug(f"Client session disconnected {session_id}")
+
+            logger.debug("Starting SSE response task")
+            tg.start_soon(response_wrapper, scope, receive, send)
+
+            logger.debug("Yielding read and write streams")
+            yield (read_stream, write_stream)

fastmcp/server/http.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import AsyncGenerator, Callable, Generator
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 from mcp.server.auth.middleware.auth_context import AuthContextMiddleware
 from mcp.server.auth.middleware.bearer_auth import (
@@ -13,17 +13,16 @@ from mcp.server.auth.middleware.bearer_auth import (
 from mcp.server.auth.provider import OAuthAuthorizationServerProvider
 from mcp.server.auth.routes import create_auth_routes
 from mcp.server.auth.settings import AuthSettings
-from mcp.server.sse import SseServerTransport
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
 from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.requests import Request
 from starlette.responses import Response
-from starlette.routing import Mount, Route
+from starlette.routing import BaseRoute, Mount, Route
 from starlette.types import Receive, Scope, Send
 
-# This import is vendored until it is finalized in the upstream SDK
-from fastmcp.server.streamable_http_manager import StreamableHTTPSessionManager
+from fastmcp.low_level.sse_server_transport import SseServerTransport
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -65,7 +64,7 @@ class RequestContextMiddleware:
 def setup_auth_middleware_and_routes(
     auth_server_provider: OAuthAuthorizationServerProvider | None,
     auth_settings: AuthSettings | None,
-) -> tuple[list[Middleware], list[Route | Mount], list[str]]:
+) -> tuple[list[Middleware], list[BaseRoute], list[str]]:
     """Set up authentication middleware and routes if auth is enabled.
 
     Args:
@@ -76,7 +75,7 @@ def setup_auth_middleware_and_routes(
         Tuple of (middleware, auth_routes, required_scopes)
     """
     middleware: list[Middleware] = []
-    auth_routes: list[Route | Mount] = []
+    auth_routes: list[BaseRoute] = []
     required_scopes: list[str] = []
 
     if auth_server_provider:
@@ -109,9 +108,9 @@ def setup_auth_middleware_and_routes(
 
 
 def create_base_app(
-    routes: list[Route | Mount],
+    routes: list[BaseRoute],
     middleware: list[Middleware],
-    debug: bool,
+    debug: bool = False,
     lifespan: Callable | None = None,
 ) -> Starlette:
     """Create a base Starlette app with common middleware and routes.
@@ -128,17 +127,12 @@ def create_base_app(
     # Always add RequestContextMiddleware as the outermost middleware
     middleware.append(Middleware(RequestContextMiddleware))
 
-    # Create the app
-    app_kwargs = {
-        "debug": debug,
-        "routes": routes,
-        "middleware": middleware,
-    }
-
-    if lifespan:
-        app_kwargs["lifespan"] = lifespan
-
-    return Starlette(**app_kwargs)
+    return Starlette(
+        routes=routes,
+        middleware=middleware,
+        debug=debug,
+        lifespan=lifespan,
+    )
 
 
 def create_sse_app(
@@ -148,7 +142,8 @@ def create_sse_app(
     auth_server_provider: OAuthAuthorizationServerProvider | None = None,
     auth_settings: AuthSettings | None = None,
     debug: bool = False,
-    additional_routes: list[Route] | list[Mount] | list[Route | Mount] | None = None,
+    routes: list[BaseRoute] | None = None,
+    middleware: list[Middleware] | None = None,
 ) -> Starlette:
     """Return an instance of the SSE server app.
 
@@ -159,11 +154,15 @@ def create_sse_app(
         auth_server_provider: Optional auth provider
         auth_settings: Optional auth settings
         debug: Whether to enable debug mode
-        additional_routes: Optional list of custom routes
-
+        routes: Optional list of custom routes
+        middleware: Optional list of middleware
     Returns:
         A Starlette application with RequestContextMiddleware
     """
+
+    server_routes: list[BaseRoute] = []
+    server_middleware: list[Middleware] = []
+
     # Set up SSE transport
     sse = SseServerTransport(message_path)
 
@@ -178,24 +177,24 @@ def create_sse_app(
         return Response()
 
     # Get auth middleware and routes
-    middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
+    auth_middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
         auth_server_provider, auth_settings
     )
 
-    # Initialize routes with auth routes
-    routes: list[Route | Mount] = auth_routes.copy()
+    server_routes.extend(auth_routes)
+    server_middleware.extend(auth_middleware)
 
     # Add SSE routes with or without auth
     if auth_server_provider:
         # Auth is enabled, wrap endpoints with RequireAuthMiddleware
-        routes.append(
+        server_routes.append(
             Route(
                 sse_path,
                 endpoint=RequireAuthMiddleware(handle_sse, required_scopes),
                 methods=["GET"],
             )
         )
-        routes.append(
+        server_routes.append(
             Mount(
                 message_path,
                 app=RequireAuthMiddleware(sse.handle_post_message, required_scopes),
@@ -206,14 +205,14 @@ def create_sse_app(
         async def sse_endpoint(request: Request) -> Response:
             return await handle_sse(request.scope, request.receive, request._send)  # type: ignore[reportPrivateUsage]
 
-        routes.append(
+        server_routes.append(
             Route(
                 sse_path,
                 endpoint=sse_endpoint,
                 methods=["GET"],
             )
         )
-        routes.append(
+        server_routes.append(
             Mount(
                 message_path,
                 app=sse.handle_post_message,
@@ -221,11 +220,19 @@ def create_sse_app(
         )
 
     # Add custom routes with lowest precedence
-    if additional_routes:
-        routes.extend(cast(list[Route | Mount], additional_routes))
+    if routes:
+        server_routes.extend(routes)
+
+    # Add middleware
+    if middleware:
+        server_middleware.extend(middleware)
 
     # Create and return the app
-    return create_base_app(routes, middleware, debug)
+    return create_base_app(
+        routes=server_routes,
+        middleware=server_middleware,
+        debug=debug,
+    )
 
 
 def create_streamable_http_app(
@@ -237,7 +244,8 @@ def create_streamable_http_app(
     json_response: bool = False,
     stateless_http: bool = False,
     debug: bool = False,
-    additional_routes: list[Route] | list[Mount] | list[Route | Mount] | None = None,
+    routes: list[BaseRoute] | None = None,
+    middleware: list[Middleware] | None = None,
 ) -> Starlette:
     """Return an instance of the StreamableHTTP server app.
 
@@ -250,11 +258,15 @@ def create_streamable_http_app(
         json_response: Whether to use JSON response format
         stateless_http: Whether to use stateless mode (new transport per request)
         debug: Whether to enable debug mode
-        additional_routes: Optional list of custom routes
+        routes: Optional list of custom routes
+        middleware: Optional list of middleware
 
     Returns:
         A Starlette application with StreamableHTTP support
     """
+    server_routes: list[BaseRoute] = []
+    server_middleware: list[Middleware] = []
+
     # Create session manager using the provided event store
     session_manager = StreamableHTTPSessionManager(
         app=server._mcp_server,
@@ -270,17 +282,17 @@ def create_streamable_http_app(
         await session_manager.handle_request(scope, receive, send)
 
     # Get auth middleware and routes
-    middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
+    auth_middleware, auth_routes, required_scopes = setup_auth_middleware_and_routes(
         auth_server_provider, auth_settings
     )
 
-    # Initialize routes with auth routes
-    routes: list[Route | Mount] = auth_routes.copy()
+    server_routes.extend(auth_routes)
+    server_middleware.extend(auth_middleware)
 
     # Add StreamableHTTP routes with or without auth
     if auth_server_provider:
         # Auth is enabled, wrap endpoint with RequireAuthMiddleware
-        routes.append(
+        server_routes.append(
             Mount(
                 streamable_http_path,
                 app=RequireAuthMiddleware(handle_streamable_http, required_scopes),
@@ -288,7 +300,7 @@ def create_streamable_http_app(
         )
     else:
         # No auth required
-        routes.append(
+        server_routes.append(
             Mount(
                 streamable_http_path,
                 app=handle_streamable_http,
@@ -296,8 +308,12 @@ def create_streamable_http_app(
         )
 
     # Add custom routes with lowest precedence
-    if additional_routes:
-        routes.extend(cast(list[Route | Mount], additional_routes))
+    if routes:
+        server_routes.extend(routes)
+
+    # Add middleware
+    if middleware:
+        server_middleware.extend(middleware)
 
     # Create a lifespan manager to start and stop the session manager
     @asynccontextmanager
@@ -306,4 +322,9 @@ def create_streamable_http_app(
             yield
 
     # Create and return the app with lifespan
-    return create_base_app(routes, middleware, debug, lifespan)
+    return create_base_app(
+        routes=server_routes,
+        middleware=server_middleware,
+        debug=debug,
+        lifespan=lifespan,
+    )

fastmcp/server/proxy.py

@@ -124,7 +124,7 @@ class ProxyTemplate(ResourceTemplate):
         params: dict[str, Any],
         context: Context | None = None,
     ) -> ProxyResource:
-        # dont use the provided uri, because it may not be the same as the
+        # don't use the provided uri, because it may not be the same as the
         # uri_template on the remote server.
         # quote params to ensure they are valid for the uri_template
         parameterized_uri = self.uri_template.format(

fastmcp/server/server.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import datetime
+import inspect
+import warnings
 from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import (
     AbstractAsyncContextManager,
@@ -35,9 +37,10 @@ from mcp.types import ResourceTemplate as MCPResourceTemplate
 from mcp.types import Tool as MCPTool
 from pydantic import AnyUrl
 from starlette.applications import Starlette
+from starlette.middleware import Middleware
 from starlette.requests import Request
 from starlette.responses import Response
-from starlette.routing import Route
+from starlette.routing import BaseRoute, Route
 
 import fastmcp.server
 import fastmcp.settings
@@ -147,7 +150,7 @@ class FastMCP(Generic[LifespanResultT]):
             )
         self._auth_server_provider = auth_server_provider
 
-        self._additional_http_routes: list[Route] = []
+        self._additional_http_routes: list[BaseRoute] = []
         self.dependencies = self.settings.dependencies
 
         # Set up MCP protocol handlers
@@ -169,7 +172,7 @@ class FastMCP(Generic[LifespanResultT]):
 
     async def run_async(
         self,
-        transport: Literal["stdio", "sse", "streamable-http"] | None = None,
+        transport: Literal["stdio", "streamable-http", "sse"] | None = None,
         **transport_kwargs: Any,
     ) -> None:
         """Run the FastMCP server asynchronously.
@@ -179,19 +182,21 @@ class FastMCP(Generic[LifespanResultT]):
         """
         if transport is None:
             transport = "stdio"
-        if transport not in ["stdio", "sse", "streamable-http"]:
+        if transport not in ["stdio", "streamable-http", "sse"]:
             raise ValueError(f"Unknown transport: {transport}")
 
         if transport == "stdio":
             await self.run_stdio_async(**transport_kwargs)
+        elif transport == "streamable-http":
+            await self.run_http_async(transport="streamable-http", **transport_kwargs)
         elif transport == "sse":
-            await self.run_sse_async(**transport_kwargs)
-        else:  # transport == "streamable-http"
-            await self.run_streamable_http_async(**transport_kwargs)
+            await self.run_http_async(transport="sse", **transport_kwargs)
+        else:
+            raise ValueError(f"Unknown transport: {transport}")
 
     def run(
         self,
-        transport: Literal["stdio", "sse", "streamable-http"] | None = None,
+        transport: Literal["stdio", "streamable-http", "sse"] | None = None,
         **transport_kwargs: Any,
     ) -> None:
         """Run the FastMCP server. Note this is a synchronous function.
@@ -713,22 +718,31 @@ class FastMCP(Generic[LifespanResultT]):
                 self._mcp_server.create_initialization_options(),
             )
 
-    async def run_sse_async(
+    async def run_http_async(
         self,
+        transport: Literal["streamable-http", "sse"] = "streamable-http",
         host: str | None = None,
         port: int | None = None,
         log_level: str | None = None,
         path: str | None = None,
-        message_path: str | None = None,
         uvicorn_config: dict | None = None,
     ) -> None:
-        """Run the server using SSE transport."""
+        """Run the server using HTTP transport.
+
+        Args:
+            transport: Transport protocol to use - either "streamable-http" (default) or "sse"
+            host: Host address to bind to (defaults to settings.host)
+            port: Port to bind to (defaults to settings.port)
+            log_level: Log level for the server (defaults to settings.log_level)
+            path: Path for the endpoint (defaults to settings.streamable_http_path or settings.sse_path)
+            uvicorn_config: Additional configuration for the Uvicorn server
+        """
         uvicorn_config = uvicorn_config or {}
-        # the SSE app hangs even when a signal is sent, so we disable the
-        # timeout to make it possible to close immediately. see
-        # https://github.com/jlowin/fastmcp/issues/296
         uvicorn_config.setdefault("timeout_graceful_shutdown", 0)
-        app = self.sse_app(path=path, message_path=message_path)
+        # lifespan is required for streamable http
+        uvicorn_config["lifespan"] = "on"
+
+        app = self.http_app(path=path, transport=transport)
 
         config = uvicorn.Config(
             app,
@@ -740,12 +754,58 @@ class FastMCP(Generic[LifespanResultT]):
         server = uvicorn.Server(config)
         await server.serve()
 
+    async def run_sse_async(
+        self,
+        host: str | None = None,
+        port: int | None = None,
+        log_level: str | None = None,
+        path: str | None = None,
+        message_path: str | None = None,
+        uvicorn_config: dict | None = None,
+    ) -> None:
+        """Run the server using SSE transport."""
+        warnings.warn(
+            inspect.cleandoc(
+                """
+                The run_sse_async method is deprecated. Use run_http_async for a
+                modern (non-SSE) alternative, or create an SSE app with
+                `fastmcp.server.http.create_sse_app` and run it directly.
+                """
+            ),
+            DeprecationWarning,
+        )
+        await self.run_http_async(
+            transport="sse",
+            host=host,
+            port=port,
+            log_level=log_level,
+            path=path,
+            uvicorn_config=uvicorn_config,
+        )
+
     def sse_app(
         self,
         path: str | None = None,
         message_path: str | None = None,
+        middleware: list[Middleware] | None = None,
     ) -> Starlette:
-        """Return an instance of the SSE server app."""
+        """
+        Create a Starlette app for the SSE server.
+
+        Args:
+            path: The path to the SSE endpoint
+            message_path: The path to the message endpoint
+            middleware: A list of middleware to apply to the app
+        """
+        warnings.warn(
+            inspect.cleandoc(
+                """
+                The sse_app method is deprecated. Use http_app as a modern (non-SSE)
+                alternative, or call `fastmcp.server.http.create_sse_app` directly.
+                """
+            ),
+            DeprecationWarning,
+        )
         return create_sse_app(
             server=self,
             message_path=message_path or self.settings.message_path,
@@ -753,24 +813,70 @@ class FastMCP(Generic[LifespanResultT]):
             auth_server_provider=self._auth_server_provider,
             auth_settings=self.settings.auth,
             debug=self.settings.debug,
-            additional_routes=self._additional_http_routes,
+            routes=self._additional_http_routes,
+            middleware=middleware,
         )
 
-    def streamable_http_app(self, path: str | None = None) -> Starlette:
-        """Return an instance of the StreamableHTTP server app."""
-        from fastmcp.server.http import create_streamable_http_app
+    def streamable_http_app(
+        self,
+        path: str | None = None,
+        middleware: list[Middleware] | None = None,
+    ) -> Starlette:
+        """
+        Create a Starlette app for the StreamableHTTP server.
 
-        return create_streamable_http_app(
-            server=self,
-            streamable_http_path=path or self.settings.streamable_http_path,
-            event_store=None,
-            auth_server_provider=self._auth_server_provider,
-            auth_settings=self.settings.auth,
-            json_response=self.settings.json_response,
-            stateless_http=self.settings.stateless_http,
-            debug=self.settings.debug,
-            additional_routes=self._additional_http_routes,
+        Args:
+            path: The path to the StreamableHTTP endpoint
+            middleware: A list of middleware to apply to the app
+        """
+        warnings.warn(
+            "The streamable_http_app method is deprecated. Use http_app() instead.",
+            DeprecationWarning,
         )
+        return self.http_app(path=path, middleware=middleware)
+
+    def http_app(
+        self,
+        path: str | None = None,
+        middleware: list[Middleware] | None = None,
+        transport: Literal["streamable-http", "sse"] = "streamable-http",
+    ) -> Starlette:
+        """Create a Starlette app using the specified HTTP transport.
+
+        Args:
+            path: The path for the HTTP endpoint
+            middleware: A list of middleware to apply to the app
+            transport: Transport protocol to use - either "streamable-http" (default) or "sse"
+
+        Returns:
+            A Starlette application configured with the specified transport
+        """
+        from fastmcp.server.http import create_streamable_http_app
+
+        if transport == "streamable-http":
+            return create_streamable_http_app(
+                server=self,
+                streamable_http_path=path or self.settings.streamable_http_path,
+                event_store=None,
+                auth_server_provider=self._auth_server_provider,
+                auth_settings=self.settings.auth,
+                json_response=self.settings.json_response,
+                stateless_http=self.settings.stateless_http,
+                debug=self.settings.debug,
+                routes=self._additional_http_routes,
+                middleware=middleware,
+            )
+        elif transport == "sse":
+            return create_sse_app(
+                server=self,
+                message_path=path or self.settings.message_path,
+                sse_path=path or self.settings.sse_path,
+                auth_server_provider=self._auth_server_provider,
+                auth_settings=self.settings.auth,
+                debug=self.settings.debug,
+                routes=self._additional_http_routes,
+                middleware=middleware,
+            )
 
     async def run_streamable_http_async(
         self,
@@ -780,23 +886,18 @@ class FastMCP(Generic[LifespanResultT]):
         path: str | None = None,
         uvicorn_config: dict | None = None,
     ) -> None:
-        """Run the server using StreamableHTTP transport."""
-        uvicorn_config = uvicorn_config or {}
-        uvicorn_config.setdefault("timeout_graceful_shutdown", 0)
-
-        app = self.streamable_http_app(path=path)
-
-        config = uvicorn.Config(
-            app,
-            host=host or self.settings.host,
-            port=port or self.settings.port,
-            log_level=log_level or self.settings.log_level.lower(),
-            # lifespan is required for streamable http
-            lifespan="on",
-            **uvicorn_config,
+        warnings.warn(
+            "The run_streamable_http_async method is deprecated. Use run_http_async instead.",
+            DeprecationWarning,
+        )
+        await self.run_http_async(
+            transport="streamable-http",
+            host=host,
+            port=port,
+            log_level=log_level,
+            path=path,
+            uvicorn_config=uvicorn_config,
         )
-        server = uvicorn.Server(config)
-        await server.serve()
 
     def mount(
         self,
@@ -892,7 +993,7 @@ class FastMCP(Generic[LifespanResultT]):
         future changes to the imported server will not be reflected in the
         importing server. Server-level configurations and lifespans are not imported.
 
-        When an server is mounted: - The tools are imported with prefixed names
+        When a server is mounted: - The tools are imported with prefixed names
         using the tool_separator
           Example: If server has a tool named "get_weather", it will be
           available as "weatherget_weather"

fastmcp/tools/tool.py

@@ -192,7 +192,7 @@ def _convert_to_content(
                 other_content.append(item)
         if other_content:
             other_content = _convert_to_content(
-                other_content, _process_as_single_item=True
+                other_content, serializer=serializer, _process_as_single_item=True
             )
 
         return other_content + mcp_types

fastmcp/utilities/tests.py

@@ -55,7 +55,7 @@ def temporary_settings(**kwargs: Any):
 def _run_server(mcp_server: FastMCP, transport: Literal["sse"], port: int) -> None:
     # Some Starlette apps are not pickleable, so we need to create them here based on the indicated transport
     if transport == "sse":
-        app = mcp_server.sse_app()
+        app = mcp_server.http_app(transport="sse")
     else:
         raise ValueError(f"Invalid transport: {transport}")
     uvicorn_server = uvicorn.Server(

{fastmcp-2.3.0rc1.dist-info → fastmcp-2.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.3.0rc1
+Version: 2.3.2
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -19,7 +19,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: mcp
+Requires-Dist: mcp<2.0.0,>=1.8.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 > [!NOTE]
 > #### FastMCP 2.0 & The Official MCP SDK
 >
-> Recognize the `FastMCP` name? You might have used the version integrated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
+> Recognize the `FastMCP` name? You might have seen the version that was contributed to the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
 >
 > **Welcome to FastMCP 2.0!** This is the actively developed successor, and it significantly expands on 1.0 by introducing powerful client capabilities, server proxying & composition, OpenAPI/FastAPI integration, and more advanced features.
 >
@@ -76,7 +76,13 @@ fastmcp run server.py
 
 ### 📚 Documentation
 
-This readme provides only a high-level overview. For detailed guides, API references, and advanced patterns, please refer to the complete FastMCP documentation at **[gofastmcp.com](https://gofastmcp.com)**.
+FastMCP's complete documentation is available at **[gofastmcp.com](https://gofastmcp.com)**, including detailed guides, API references, and advanced patterns. This readme provides only a high-level overview.
+
+Documentation is also available in [llms.txt format](https://llmstxt.org/), which is a simple markdown standard that LLMs can consume easily. 
+
+There are two ways to access the LLM-friendly documentation:
+- [`llms.txt`](https://gofastmcp.com/llms.txt) is essentially a sitemap, listing all the pages in the documentation.
+- [`llms-full.txt`](https://gofastmcp.com/llms-full.txt) contains the entire documentation. Note this may exceed the context window of your LLM.
 
 ---
 
@@ -302,50 +308,40 @@ Learn more: [**OpenAPI Integration**](https://gofastmcp.com/patterns/openapi) |
 
 ## Running Your Server
 
-You can run your FastMCP server in several ways:
-
-1.  **Development (`fastmcp dev`)**: Recommended for building and testing. Provides an interactive testing environment with the MCP Inspector.
-    ```bash
-    fastmcp dev server.py
-    # Optionally add temporary dependencies
-    fastmcp dev server.py --with pandas numpy
-    ```
-
-2. **FastMCP CLI**: Run your server with the FastMCP CLI. This can autodetect and load your server object and run it with any transport configuration you want. 
-    ```bash
-    fastmcp run path/to/server.py:server_object
-
-    # Run as SSE on port 4200
-    fastmcp run path/to/server.py:server_object --transport sse --port 4200
-    ```
-    FastMCP will auto-detect the server object if it's named `mcp`, `app`, or `server`. In these cases, you can omit the `:server_object` part unless you need to select a specific object.
-
-3.  **Direct Execution**: For maximum compatibility with the MCP ecosystem, you can run your server directly as part of a Python script. You will typically do this within an `if __name__ == "__main__":` block in your script:
-    ```python
-    # Add this to server.py
-    if __name__ == "__main__":
-        # Default: runs stdio transport
-        mcp.run()
-
-        # Example: Run with SSE transport on a specific port
-        mcp.run(transport="sse", host="127.0.0.1", port=9000)
-    ```
-    Run your script:
-    ```bash
-    python server.py
-    # or using uv to manage the environment
-    uv run python server.py
-    ```
-4.  **Claude Desktop Integration (`fastmcp install`)**: The easiest way to make your server persistently available in the Claude Desktop app. It handles creating an isolated environment using `uv`.
-    ```bash
-    fastmcp install server.py --name "My Analysis Tool"
-    # Optionally add dependencies and environment variables
-    fastmcp install server.py --with requests -v API_KEY=123 -f .env
-    ```
-
-
-See the [**Server Documentation**](https://gofastmcp.com/servers/fastmcp#running-the-server) for more details on transports and configuration.
+The main way to run a FastMCP server is by calling the `run()` method on your server instance:
+
+```python
+# server.py
+from fastmcp import FastMCP
+
+mcp = FastMCP("Demo 🚀")
+
+@mcp.tool()
+def hello(name: str) -> str:
+    return f"Hello, {name}!"
+
+if __name__ == "__main__":
+    mcp.run()  # Default: uses STDIO transport
+```
+
+FastMCP supports three transport protocols:
+
+**STDIO (Default)**: Best for local tools and command-line scripts.
+```python
+mcp.run(transport="stdio")  # Default, so transport argument is optional
+```
+
+**Streamable HTTP**: Recommended for web deployments.
+```python
+mcp.run(transport="streamable-http", host="127.0.0.1", port=8000, path="/mcp")
+```
+
+**SSE**: For compatibility with existing SSE clients.
+```python
+mcp.run(transport="sse", host="127.0.0.1", port=8000)
+```
 
+See the [**Running Server Documentation**](https://gofastmcp.com/deployment/running-server) for more details.
 
 ## Contributing
 

{fastmcp-2.3.0rc1.dist-info → fastmcp-2.3.2.dist-info}/RECORD

@@ -4,7 +4,7 @@ fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/settings.py,sha256=rDClnYEpYjEl8VsvvVrKp9oaE4YLfNQcMoZ41H_bDL0,2968
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=7s5RsV8D_tPs20EJcrCvyO-i69DmV60OiRGD21oEJSI,15728
+fastmcp/cli/cli.py,sha256=Tb-WiIXFZiq4nqlZ6LMXN2iYY30clC4Om_gP89HbJcE,15641
 fastmcp/client/__init__.py,sha256=BXO9NUhntZ5GnUACfaRCzDJ5IzxqFJs8qKG-CRMSco4,490
 fastmcp/client/base.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastmcp/client/client.py,sha256=zfSLWSGqiBoADveKehsAL66CdyGGqmzVHR1q46zfdQY,15479
@@ -21,6 +21,9 @@ fastmcp/contrib/mcp_mixin/README.md,sha256=9DDTJXWkA3yv1fp5V58gofmARPQ2xWDhblYGv
 fastmcp/contrib/mcp_mixin/__init__.py,sha256=aw9IQ1ssNjCgws4ZNt8bkdpossAAGVAwwjBpMp9O5ZQ,153
 fastmcp/contrib/mcp_mixin/example.py,sha256=GnunkXmtG5hLLTUsM8aW5ZURU52Z8vI4tNLl-fK7Dg0,1228
 fastmcp/contrib/mcp_mixin/mcp_mixin.py,sha256=cfIRbnSxsVzglTD-auyTE0izVQeHP7Oz18qzYoBZJgg,7899
+fastmcp/low_level/README.md,sha256=IRvElvOOc_RLLsqbUm7e6VOEwrKHPJeox0pV7JVKHWw,106
+fastmcp/low_level/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmcp/low_level/sse_server_transport.py,sha256=pUG3AL4Wjf9LgH9fj1l3emGEjFDFDhmKcDfgiiFJcuQ,4448
 fastmcp/prompts/__init__.py,sha256=An8uMBUh9Hrb7qqcn_5_Hent7IOeSh7EA2IUVsIrtHc,179
 fastmcp/prompts/prompt.py,sha256=psc-YiBRttbjETINaP9P9QV328yk96mDBsZgjOHVyKM,7777
 fastmcp/prompts/prompt_manager.py,sha256=9VcioLE-AoUKe1e9SynNQME9SvWy0q1QAvO1ewIWVmI,3126
@@ -32,13 +35,12 @@ fastmcp/resources/types.py,sha256=QPDeka_cM1hmvwW4FeFhqy6BEEi4MlwtpvhWUVWh5Fc,64
 fastmcp/server/__init__.py,sha256=bMD4aQD4yJqLz7-mudoNsyeV8UgQfRAg3PRwPvwTEds,119
 fastmcp/server/context.py,sha256=ykitQygA7zT5prbFTLCuYlnAzuljf_9ErUT0FYBPv3E,8135
 fastmcp/server/dependencies.py,sha256=1utkxFsV37HZcWBwI69JyngVN2ppGO_PEgxUlUHHy_Q,742
-fastmcp/server/http.py,sha256=c_J6y1jkasC3WMCzo3LVXMwJbGrHVwQO2Qtl4IP5RlY,10085
+fastmcp/server/http.py,sha256=utl7vJkMvKUnKIflCptVWk1oqOi7_sJJHqUl22g4JC8,10473
 fastmcp/server/openapi.py,sha256=0nANnwHJ5VZInNyo2f9ErmO0K3igMv6bwyxf3G-BSls,23473
-fastmcp/server/proxy.py,sha256=qcBD2wWMcXA4dhqppStVH4UhsyWm0cpPUuItLpO6H6A,9621
-fastmcp/server/server.py,sha256=usocXySZvmrp6GOJzQQrh1lUiAyVMkRnJhk4NBhp0FQ,40827
-fastmcp/server/streamable_http_manager.py,sha256=noCZSybvbotyiHZbJ7PRIB6peFBGvjIM2Xavs0pLtGQ,8879
+fastmcp/server/proxy.py,sha256=LDTjzc_iQj8AldsfMU37flGRAfJic1w6qsherfyHPAA,9622
+fastmcp/server/server.py,sha256=Srj_aytCxsO7NjSwajW5gj55ilbHpgJlewepnNG9ToA,44420
 fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
-fastmcp/tools/tool.py,sha256=lr9F90-A36Z6DT4LScJBW88uFq8xrSv00ivFxiERJe8,7786
+fastmcp/tools/tool.py,sha256=HGcHjMecqAeN6eI-IfE_2UBcd1KpTV-VOTFLx9tlbpU,7809
 fastmcp/tools/tool_manager.py,sha256=p2nHyLFgz28tbsLpWOurkbWRU2Z34_HcDohjrvwjI0E,3369
 fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
 fastmcp/utilities/cache.py,sha256=aV3oZ-ZhMgLSM9iAotlUlEy5jFvGXrVo0Y5Bj4PBtqY,707
@@ -46,10 +48,10 @@ fastmcp/utilities/decorators.py,sha256=AjhjsetQZF4YOPV5MTZmIxO21iFp_4fDIS3O2_KNC
 fastmcp/utilities/json_schema.py,sha256=mSakhP8bENxhLFMwHJSxJAFllNeByIBDjVohwlpac6w,2026
 fastmcp/utilities/logging.py,sha256=zav8pnFxG_fvGJHUV2XpobmT9WVrmv1mlQBSCz-CPx4,1159
 fastmcp/utilities/openapi.py,sha256=Er3G1MyFwiWVxZXicXtD2j-BvttHEDTi1dgkq1KiBQc,51073
-fastmcp/utilities/tests.py,sha256=uUV-8CkhCe5zZJkxhgJXnxrjJ3Yq7cCMZN8xWKGuqdY,3181
+fastmcp/utilities/tests.py,sha256=9GOxIENGU6vRTVooY5vxb5dM6vltpmgWKSKm8htQ4Yc,3197
 fastmcp/utilities/types.py,sha256=6CcqAQ1QqCO2HGSFlPS6FO5JRWnacjCcO2-EhyEnZV0,4400
-fastmcp-2.3.0rc1.dist-info/METADATA,sha256=5hLCFQ8nJWFwllIUbC2D0V9YlOaA7lnNuJwoXTQrw7s,16385
-fastmcp-2.3.0rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.3.0rc1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.3.0rc1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.3.0rc1.dist-info/RECORD,,
+fastmcp-2.3.2.dist-info/METADATA,sha256=XFBGtiKoYu43JZQAfXtaTDL_8qtWIk_7AIJen4XhqmA,15754
+fastmcp-2.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.3.2.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.3.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.3.2.dist-info/RECORD,,

fastmcp/server/streamable_http_manager.py

@@ -1,241 +0,0 @@
-"""StreamableHTTP Session Manager for MCP servers."""
-
-# follows https://github.com/modelcontextprotocol/python-sdk/blob/ihrpr/shttp/src/mcp/server/streamable_http_manager.py
-# and can be removed once that spec is finalized
-
-from __future__ import annotations
-
-import contextlib
-import logging
-from collections.abc import AsyncIterator
-from http import HTTPStatus
-from typing import Any
-from uuid import uuid4
-
-import anyio
-from anyio.abc import TaskStatus
-from mcp.server.lowlevel.server import Server as MCPServer
-from mcp.server.streamable_http import (
-    MCP_SESSION_ID_HEADER,
-    EventStore,
-    StreamableHTTPServerTransport,
-)
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.types import Receive, Scope, Send
-
-logger = logging.getLogger(__name__)
-
-
-class StreamableHTTPSessionManager:
-    """
-    Manages StreamableHTTP sessions with optional resumability via event store.
-
-    This class abstracts away the complexity of session management, event storage,
-    and request handling for StreamableHTTP transports. It handles:
-
-    1. Session tracking for clients
-    2. Resumability via an optional event store
-    3. Connection management and lifecycle
-    4. Request handling and transport setup
-
-    Args:
-        app: The MCP server instance
-        event_store: Optional event store for resumability support.
-                     If provided, enables resumable connections where clients
-                     can reconnect and receive missed events.
-                     If None, sessions are still tracked but not resumable.
-        json_response: Whether to use JSON responses instead of SSE streams
-        stateless: If True, creates a completely fresh transport for each request
-                   with no session tracking or state persistence between requests.
-
-    """
-
-    def __init__(
-        self,
-        app: MCPServer[Any],
-        event_store: EventStore | None = None,
-        json_response: bool = False,
-        stateless: bool = False,
-    ):
-        self.app = app
-        self.event_store = event_store
-        self.json_response = json_response
-        self.stateless = stateless
-
-        # Session tracking (only used if not stateless)
-        self._session_creation_lock = anyio.Lock()
-        self._server_instances: dict[str, StreamableHTTPServerTransport] = {}
-
-        # The task group will be set during lifespan
-        self._task_group = None
-
-    @contextlib.asynccontextmanager
-    async def run(self) -> AsyncIterator[None]:
-        """
-        Run the session manager with proper lifecycle management.
-
-        This creates and manages the task group for all session operations.
-
-        Use this in the lifespan context manager of your Starlette app:
-
-        @contextlib.asynccontextmanager
-        async def lifespan(app: Starlette) -> AsyncIterator[None]:
-            async with session_manager.run():
-                yield
-        """
-        async with anyio.create_task_group() as tg:
-            # Store the task group for later use
-            self._task_group = tg
-            logger.info("StreamableHTTP session manager started")
-            try:
-                yield  # Let the application run
-            finally:
-                logger.info("StreamableHTTP session manager shutting down")
-                # Cancel task group to stop all spawned tasks
-                tg.cancel_scope.cancel()
-                self._task_group = None
-                # Clear any remaining server instances
-                self._server_instances.clear()
-
-    async def handle_request(
-        self,
-        scope: Scope,
-        receive: Receive,
-        send: Send,
-    ) -> None:
-        """
-        Process ASGI request with proper session handling and transport setup.
-
-        Dispatches to the appropriate handler based on stateless mode.
-
-        Args:
-            scope: ASGI scope
-            receive: ASGI receive function
-            send: ASGI send function
-        """
-        if self._task_group is None:
-            raise RuntimeError(
-                "Task group is not initialized. Make sure to use the run()."
-            )
-
-        # Dispatch to the appropriate handler
-        if self.stateless:
-            await self._handle_stateless_request(scope, receive, send)
-        else:
-            await self._handle_stateful_request(scope, receive, send)
-
-    async def _handle_stateless_request(
-        self,
-        scope: Scope,
-        receive: Receive,
-        send: Send,
-    ) -> None:
-        """
-        Process request in stateless mode - creating a new transport for each request.
-
-        Args:
-            scope: ASGI scope
-            receive: ASGI receive function
-            send: ASGI send function
-        """
-        logger.debug("Stateless mode: Creating new transport for this request")
-        # No session ID needed in stateless mode
-        http_transport = StreamableHTTPServerTransport(
-            mcp_session_id=None,  # No session tracking in stateless mode
-            is_json_response_enabled=self.json_response,
-            event_store=None,  # No event store in stateless mode
-        )
-
-        # Start server in a new task
-        async def run_stateless_server(
-            *, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED
-        ):
-            async with http_transport.connect() as streams:
-                read_stream, write_stream = streams
-                task_status.started()
-                await self.app.run(
-                    read_stream,
-                    write_stream,
-                    self.app.create_initialization_options(),
-                    stateless=True,
-                )
-
-        # Assert task group is not None for type checking
-        assert self._task_group is not None
-        # Start the server task
-        await self._task_group.start(run_stateless_server)
-
-        # Handle the HTTP request and return the response
-        await http_transport.handle_request(scope, receive, send)
-
-    async def _handle_stateful_request(
-        self,
-        scope: Scope,
-        receive: Receive,
-        send: Send,
-    ) -> None:
-        """
-        Process request in stateful mode - maintaining session state between requests.
-
-        Args:
-            scope: ASGI scope
-            receive: ASGI receive function
-            send: ASGI send function
-        """
-        request = Request(scope, receive)
-        request_mcp_session_id = request.headers.get(MCP_SESSION_ID_HEADER)
-
-        # Existing session case
-        if (
-            request_mcp_session_id is not None
-            and request_mcp_session_id in self._server_instances
-        ):
-            transport = self._server_instances[request_mcp_session_id]
-            logger.debug("Session already exists, handling request directly")
-            await transport.handle_request(scope, receive, send)
-            return
-
-        if request_mcp_session_id is None:
-            # New session case
-            logger.debug("Creating new transport")
-            async with self._session_creation_lock:
-                new_session_id = uuid4().hex
-                http_transport = StreamableHTTPServerTransport(
-                    mcp_session_id=new_session_id,
-                    is_json_response_enabled=self.json_response,
-                    event_store=self.event_store,  # May be None (no resumability)
-                )
-
-                assert http_transport.mcp_session_id is not None
-                self._server_instances[http_transport.mcp_session_id] = http_transport
-                logger.info(f"Created new transport with session ID: {new_session_id}")
-
-                # Define the server runner
-                async def run_server(
-                    *, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED
-                ) -> None:
-                    async with http_transport.connect() as streams:
-                        read_stream, write_stream = streams
-                        task_status.started()
-                        await self.app.run(
-                            read_stream,
-                            write_stream,
-                            self.app.create_initialization_options(),
-                            stateless=False,  # Stateful mode
-                        )
-
-                # Assert task group is not None for type checking
-                assert self._task_group is not None
-                # Start the server task
-                await self._task_group.start(run_server)
-
-                # Handle the HTTP request and return the response
-                await http_transport.handle_request(scope, receive, send)
-        else:
-            # Invalid session ID
-            response = Response(
-                "Bad Request: No valid session ID provided",
-                status_code=HTTPStatus.BAD_REQUEST,
-            )
-            await response(scope, receive, send)