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

fastmcp/__init__.py

@@ -2,9 +2,10 @@
 
 from importlib.metadata import version
 
-
 from fastmcp.server.server import FastMCP
 from fastmcp.server.context import Context
+import fastmcp.server
+
 from fastmcp.client import Client
 from fastmcp.utilities.types import Image
 from . import client, settings

fastmcp/cli/cli.py

@@ -334,7 +334,7 @@ def run(
         str | None,
         typer.Option(
             "--host",
-            help="Host to bind to when using sse transport (default: 0.0.0.0)",
+            help="Host to bind to when using sse transport (default: 127.0.0.1)",
         ),
     ] = None,
     port: Annotated[

fastmcp/client/client.py

@@ -108,9 +108,10 @@ class Client:
 
     # --- MCP Client Methods ---
 
-    async def ping(self) -> None:
+    async def ping(self) -> bool:
         """Send a ping request."""
-        await self.session.send_ping()
+        result = await self.session.send_ping()
+        return isinstance(result, mcp.types.EmptyResult)
 
     async def progress(
         self,

fastmcp/client/transports.py

@@ -1,9 +1,11 @@
 import abc
 import contextlib
 import datetime
+import inspect
 import os
 import shutil
 import sys
+import warnings
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import Any, TypedDict
@@ -18,6 +20,7 @@ from mcp.client.session import (
 )
 from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
 from mcp.client.websocket import websocket_client
 from mcp.shared.memory import create_connected_server_and_client_session
 from pydantic import AnyUrl
@@ -125,6 +128,33 @@ class SSETransport(ClientTransport):
         return f"<SSE(url='{self.url}')>"
 
 
+class StreamableHttpTransport(ClientTransport):
+    """Transport implementation that connects to an MCP server via Streamable HTTP Requests."""
+
+    def __init__(self, url: str | AnyUrl, headers: dict[str, str] | None = None):
+        if isinstance(url, AnyUrl):
+            url = str(url)
+        if not isinstance(url, str) or not url.startswith("http"):
+            raise ValueError("Invalid HTTP/S URL provided for Streamable HTTP.")
+        self.url = url
+        self.headers = headers or {}
+
+    @contextlib.asynccontextmanager
+    async def connect_session(
+        self, **session_kwargs: Unpack[SessionKwargs]
+    ) -> AsyncIterator[ClientSession]:
+        async with streamablehttp_client(self.url, headers=self.headers) as transport:
+            read_stream, write_stream, _ = transport
+            async with ClientSession(
+                read_stream, write_stream, **session_kwargs
+            ) as session:
+                await session.initialize()
+                yield session
+
+    def __repr__(self) -> str:
+        return f"<StreamableHttp(url='{self.url}')>"
+
+
 class StdioTransport(ClientTransport):
     """
     Base transport for connecting to an MCP server via subprocess with stdio.
@@ -422,6 +452,8 @@ def infer_transport(
     This function attempts to infer the correct transport type from the provided
     argument, handling various input types and converting them to the appropriate
     ClientTransport subclass.
+
+    For HTTP URLs, they are assumed to be Streamable HTTP URLs unless they end in `/sse`.
     """
     # the transport is already a ClientTransport
     if isinstance(transport, ClientTransport):
@@ -442,7 +474,19 @@ def infer_transport(
 
     # the transport is an http(s) URL
     elif isinstance(transport, AnyUrl | str) and str(transport).startswith("http"):
-        return SSETransport(url=transport)
+        if str(transport).rstrip("/").endswith("/sse"):
+            warnings.warn(
+                inspect.cleandoc(
+                    """
+                    As of FastMCP 2.3.0, HTTP URLs are inferred to use Streamable HTTP.
+                    The provided URL ends in `/sse`, so you may encounter unexpected behavior.
+                    If you intended to use SSE, please use the `SSETransport` class directly.
+                    """
+                ),
+                category=UserWarning,
+                stacklevel=2,
+            )
+        return StreamableHttpTransport(url=transport)
 
     # the transport is a websocket URL
     elif isinstance(transport, AnyUrl | str) and str(transport).startswith("ws"):

fastmcp/prompts/prompt.py

@@ -12,6 +12,7 @@ from mcp.types import Prompt as MCPPrompt
 from mcp.types import PromptArgument as MCPPromptArgument
 from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
 
+from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.json_schema import prune_params
 from fastmcp.utilities.types import (
     _convert_set_defaults,
@@ -20,10 +21,7 @@ from fastmcp.utilities.types import (
 )
 
 if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
-    from fastmcp.server import Context
+    pass
 
 CONTENT_TYPES = TextContent | ImageContent | EmbeddedResource
 
@@ -76,9 +74,6 @@ class Prompt(BaseModel):
         None, description="Arguments that can be passed to the prompt"
     )
     fn: Callable[..., PromptResult | Awaitable[PromptResult]]
-    context_kwarg: str | None = Field(
-        None, description="Name of the kwarg that should receive context"
-    )
 
     @classmethod
     def from_function(
@@ -87,7 +82,6 @@ class Prompt(BaseModel):
         name: str | None = None,
         description: str | None = None,
         tags: set[str] | None = None,
-        context_kwarg: str | None = None,
     ) -> Prompt:
         """Create a Prompt from a function.
 
@@ -97,7 +91,7 @@ class Prompt(BaseModel):
         - A dict (converted to a message)
         - A sequence of any of the above
         """
-        from fastmcp import Context
+        from fastmcp.server.context import Context
 
         func_name = name or fn.__name__
 
@@ -115,8 +109,8 @@ class Prompt(BaseModel):
         parameters = type_adapter.json_schema()
 
         # Auto-detect context parameter if not provided
-        if context_kwarg is None:
-            context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
+
+        context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
         if context_kwarg:
             parameters = prune_params(parameters, params=[context_kwarg])
 
@@ -141,15 +135,15 @@ class Prompt(BaseModel):
             arguments=arguments,
             fn=fn,
             tags=tags or set(),
-            context_kwarg=context_kwarg,
         )
 
     async def render(
         self,
         arguments: dict[str, Any] | None = None,
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
     ) -> list[PromptMessage]:
         """Render the prompt with arguments."""
+        from fastmcp.server.context import Context
+
         # Validate required arguments
         if self.arguments:
             required = {arg.name for arg in self.arguments if arg.required}
@@ -161,8 +155,9 @@ class Prompt(BaseModel):
         try:
             # Prepare arguments with context
             kwargs = arguments.copy() if arguments else {}
-            if self.context_kwarg is not None and context is not None:
-                kwargs[self.context_kwarg] = context
+            context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
+            if context_kwarg and context_kwarg not in kwargs:
+                kwargs[context_kwarg] = get_context()
 
             # Call function and check if result is a coroutine
             result = self.fn(**kwargs)

fastmcp/prompts/prompt_manager.py

@@ -13,10 +13,7 @@ from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
-    from fastmcp.server import Context
+    pass
 
 logger = get_logger(__name__)
 
@@ -82,19 +79,15 @@ class PromptManager:
         self,
         name: str,
         arguments: dict[str, Any] | None = None,
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
     ) -> GetPromptResult:
         """Render a prompt by name with arguments."""
         prompt = self.get_prompt(name)
         if not prompt:
             raise NotFoundError(f"Unknown prompt: {name}")
 
-        messages = await prompt.render(arguments, context=context)
+        messages = await prompt.render(arguments)
 
-        return GetPromptResult(
-            description=prompt.description,
-            messages=messages,
-        )
+        return GetPromptResult(description=prompt.description, messages=messages)
 
     def has_prompt(self, key: str) -> bool:
         """Check if a prompt exists."""

fastmcp/resources/resource.py

@@ -20,10 +20,7 @@ from pydantic import (
 from fastmcp.utilities.types import _convert_set_defaults
 
 if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
-    from fastmcp.server import Context
+    pass
 
 
 class Resource(BaseModel, abc.ABC):
@@ -66,9 +63,7 @@ class Resource(BaseModel, abc.ABC):
         raise ValueError("Either name or uri must be provided")
 
     @abc.abstractmethod
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str | bytes:
+    async def read(self) -> str | bytes:
         """Read the resource content."""
         pass
 

fastmcp/resources/resource_manager.py

@@ -109,7 +109,7 @@ class ResourceManager:
             The added resource. If a resource with the same URI already exists,
             returns the existing resource.
         """
-        resource = FunctionResource.from_function(
+        resource = FunctionResource(
             fn=fn,
             uri=AnyUrl(uri),
             name=name,
@@ -219,12 +219,11 @@ class ResourceManager:
                 return True
         return False
 
-    async def get_resource(self, uri: AnyUrl | str, context=None) -> Resource:
+    async def get_resource(self, uri: AnyUrl | str) -> Resource:
         """Get resource by URI, checking concrete resources first, then templates.
 
         Args:
             uri: The URI of the resource to get
-            context: Optional context object to pass to template resources
 
         Raises:
             NotFoundError: If no resource or template matching the URI is found.
@@ -244,7 +243,6 @@ class ResourceManager:
                     return await template.create_resource(
                         uri_str,
                         params=params,
-                        context=context,
                     )
                 except Exception as e:
                     raise ValueError(f"Error creating resource from template: {e}")

fastmcp/resources/template.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import inspect
 import re
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Annotated, Any
+from typing import Annotated, Any
 from urllib.parse import unquote
 
 from mcp.types import ResourceTemplate as MCPResourceTemplate
@@ -20,17 +20,12 @@ from pydantic import (
 )
 
 from fastmcp.resources.types import FunctionResource, Resource
+from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.types import (
     _convert_set_defaults,
     find_kwarg_by_type,
 )
 
-if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
-    from fastmcp.server import Context
-
 
 def build_regex(template: str) -> re.Pattern:
     parts = re.split(r"(\{[^}]+\})", template)
@@ -79,9 +74,6 @@ class ResourceTemplate(BaseModel):
     parameters: dict[str, Any] = Field(
         description="JSON schema for function parameters"
     )
-    context_kwarg: str | None = Field(
-        None, description="Name of the kwarg that should receive context"
-    )
 
     @field_validator("mime_type", mode="before")
     @classmethod
@@ -100,10 +92,9 @@ class ResourceTemplate(BaseModel):
         description: str | None = None,
         mime_type: str | None = None,
         tags: set[str] | None = None,
-        context_kwarg: str | None = None,
     ) -> ResourceTemplate:
         """Create a template from a function."""
-        from fastmcp import Context
+        from fastmcp.server.context import Context
 
         func_name = name or fn.__name__
         if func_name == "<lambda>":
@@ -119,8 +110,8 @@ class ResourceTemplate(BaseModel):
                 )
 
         # Auto-detect context parameter if not provided
-        if context_kwarg is None:
-            context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
+
+        context_kwarg = find_kwarg_by_type(fn, kwarg_type=Context)
 
         # Validate that URI params match function params
         uri_params = set(re.findall(r"{(\w+)(?:\*)?}", uri_template))
@@ -170,25 +161,22 @@ class ResourceTemplate(BaseModel):
             fn=fn,
             parameters=parameters,
             tags=tags or set(),
-            context_kwarg=context_kwarg,
         )
 
     def matches(self, uri: str) -> dict[str, Any] | None:
         """Check if URI matches template and extract parameters."""
         return match_uri_template(uri, self.uri_template)
 
-    async def create_resource(
-        self,
-        uri: str,
-        params: dict[str, Any],
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> Resource:
+    async def create_resource(self, uri: str, params: dict[str, Any]) -> Resource:
         """Create a resource from the template with the given parameters."""
+        from fastmcp.server.context import Context
+
         try:
             # Add context to parameters if needed
             kwargs = params.copy()
-            if self.context_kwarg is not None and context is not None:
-                kwargs[self.context_kwarg] = context
+            context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
+            if context_kwarg and context_kwarg not in kwargs:
+                kwargs[context_kwarg] = get_context()
 
             # Call function and check if result is a coroutine
             result = self.fn(**kwargs)
@@ -202,7 +190,6 @@ class ResourceTemplate(BaseModel):
                 mime_type=self.mime_type,
                 fn=lambda **kwargs: result,  # Capture result in closure
                 tags=self.tags,
-                context_kwarg=self.context_kwarg,
             )
         except Exception as e:
             raise ValueError(f"Error creating resource from template: {e}")

fastmcp/resources/types.py

@@ -15,14 +15,12 @@ import pydantic.json
 import pydantic_core
 from pydantic import Field, ValidationInfo
 
-import fastmcp
 from fastmcp.resources.resource import Resource
+from fastmcp.server.dependencies import get_context
+from fastmcp.utilities.types import find_kwarg_by_type
 
 if TYPE_CHECKING:
-    from mcp.server.session import ServerSessionT
-    from mcp.shared.context import LifespanContextT
-
-    from fastmcp.server import Context
+    pass
 
 
 class TextResource(Resource):
@@ -30,9 +28,7 @@ class TextResource(Resource):
 
     text: str = Field(description="Text content of the resource")
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str:
+    async def read(self) -> str:
         """Read the text content."""
         return self.text
 
@@ -42,9 +38,7 @@ class BinaryResource(Resource):
 
     data: bytes = Field(description="Binary content of the resource")
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> bytes:
+    async def read(self) -> bytes:
         """Read the binary content."""
         return self.data
 
@@ -63,40 +57,23 @@ class FunctionResource(Resource):
     """
 
     fn: Callable[[], Any]
-    context_kwarg: str | None = Field(
-        default=None, description="Name of the kwarg that should receive context"
-    )
 
-    @classmethod
-    def from_function(
-        cls, fn: Callable[[], Any], context_kwarg: str | None = None, **kwargs
-    ) -> FunctionResource:
-        if context_kwarg is None:
-            parameters = inspect.signature(fn).parameters
-            context_param = next(
-                (p for p in parameters.values() if p.annotation is fastmcp.Context),
-                None,
-            )
-            if context_param is not None:
-                context_kwarg = context_param.name
-        return cls(fn=fn, context_kwarg=context_kwarg, **kwargs)
-
-    async def read(
-        self,
-        context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> str | bytes:
+    async def read(self) -> str | bytes:
         """Read the resource by calling the wrapped function."""
+        from fastmcp.server.context import Context
+
         try:
             kwargs = {}
-            if self.context_kwarg is not None:
-                kwargs[self.context_kwarg] = context
+            context_kwarg = find_kwarg_by_type(self.fn, kwarg_type=Context)
+            if context_kwarg is not None:
+                kwargs[context_kwarg] = get_context()
 
             result = self.fn(**kwargs)
             if inspect.iscoroutinefunction(self.fn):
                 result = await result
 
             if isinstance(result, Resource):
-                return await result.read(context=context)
+                return await result.read()
             elif isinstance(result, bytes):
                 return result
             elif isinstance(result, str):
@@ -140,9 +117,7 @@ class FileResource(Resource):
         mime_type = info.data.get("mime_type", "text/plain")
         return not mime_type.startswith("text/")
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str | bytes:
+    async def read(self) -> str | bytes:
         """Read the file content."""
         try:
             if self.is_binary:
@@ -160,9 +135,7 @@ class HttpResource(Resource):
         default="application/json", description="MIME type of the resource content"
     )
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str | bytes:
+    async def read(self) -> str | bytes:
         """Read the HTTP content."""
         async with httpx.AsyncClient() as client:
             response = await client.get(self.url)
@@ -214,9 +187,7 @@ class DirectoryResource(Resource):
         except Exception as e:
             raise ValueError(f"Error listing directory {self.path}: {e}")
 
-    async def read(
-        self, context: Context[ServerSessionT, LifespanContextT] | None = None
-    ) -> str:  # Always returns JSON string
+    async def read(self) -> str:  # Always returns JSON string
         """Read the directory listing."""
         try:
             files = await anyio.to_thread.run_sync(self.list_files)

fastmcp/server/__init__.py

@@ -1,5 +1,6 @@
 from .server import FastMCP
 from .context import Context
+from . import dependencies
 
 
 __all__ = ["FastMCP", "Context"]

fastmcp/server/context.py

@@ -1,11 +1,14 @@
 from __future__ import annotations as _annotations
 
-from typing import Any, Generic
+import warnings
+from collections.abc import Generator
+from contextlib import contextmanager
+from contextvars import ContextVar, Token
+from dataclasses import dataclass
 
 from mcp import LoggingLevel
 from mcp.server.lowlevel.helper_types import ReadResourceContents
-from mcp.server.session import ServerSessionT
-from mcp.shared.context import LifespanContextT, RequestContext
+from mcp.shared.context import RequestContext
 from mcp.types import (
     CreateMessageResult,
     ImageContent,
@@ -13,18 +16,29 @@ from mcp.types import (
     SamplingMessage,
     TextContent,
 )
-from pydantic import BaseModel, ConfigDict
 from pydantic.networks import AnyUrl
 from starlette.requests import Request
 
+import fastmcp.server.dependencies
 from fastmcp.server.server import FastMCP
-from fastmcp.utilities.http import get_current_starlette_request
 from fastmcp.utilities.logging import get_logger
 
 logger = get_logger(__name__)
 
+_current_context: ContextVar[Context | None] = ContextVar("context", default=None)
 
-class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
+
+@contextmanager
+def set_context(context: Context) -> Generator[Context, None, None]:
+    token = _current_context.set(context)
+    try:
+        yield context
+    finally:
+        _current_context.reset(token)
+
+
+@dataclass
+class Context:
     """Context object providing access to MCP capabilities.
 
     This provides a cleaner interface to MCP's RequestContext functionality.
@@ -56,37 +70,30 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
 
     The context parameter name can be anything as long as it's annotated with Context.
     The context is optional - tools that don't need it can omit the parameter.
+
     """
 
-    _request_context: RequestContext[ServerSessionT, LifespanContextT] | None
-    _fastmcp: FastMCP | None
+    def __init__(self, fastmcp: FastMCP):
+        self.fastmcp = fastmcp
+        self._tokens: list[Token] = []
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    def __enter__(self) -> Context:
+        """Enter the context manager and set this context as the current context."""
+        # Always set this context and save the token
+        token = _current_context.set(self)
+        self._tokens.append(token)
+        return self
 
-    def __init__(
-        self,
-        *,
-        request_context: RequestContext[ServerSessionT, LifespanContextT] | None = None,
-        fastmcp: FastMCP | None = None,
-        **kwargs: Any,
-    ):
-        super().__init__(**kwargs)
-        self._request_context = request_context
-        self._fastmcp = fastmcp
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit the context manager and reset the most recent token."""
+        if self._tokens:
+            token = self._tokens.pop()
+            _current_context.reset(token)
 
     @property
-    def fastmcp(self) -> FastMCP:
-        """Access to the FastMCP server."""
-        if self._fastmcp is None:
-            raise ValueError("Context is not available outside of a request")
-        return self._fastmcp
-
-    @property
-    def request_context(self) -> RequestContext[ServerSessionT, LifespanContextT]:
+    def request_context(self) -> RequestContext:
         """Access to the underlying request context."""
-        if self._request_context is None:
-            raise ValueError("Context is not available outside of a request")
-        return self._request_context
+        return self.fastmcp._mcp_server.request_context
 
     async def report_progress(
         self, progress: float, total: float | None = None
@@ -120,10 +127,8 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
         Returns:
             The resource content as either text or bytes
         """
-        assert self._fastmcp is not None, (
-            "Context is not available outside of a request"
-        )
-        return await self._fastmcp._mcp_read_resource(uri)
+        assert self.fastmcp is not None, "Context is not available outside of a request"
+        return await self.fastmcp._mcp_read_resource(uri)
 
     async def log(
         self,
@@ -229,7 +234,14 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
 
     def get_http_request(self) -> Request:
         """Get the active starlette request."""
-        request = get_current_starlette_request()
-        if request is None:
-            raise ValueError("Request is not available outside a Starlette request")
-        return request
+
+        # Deprecation warning, added in FastMCP 2.2.11
+        warnings.warn(
+            "Context.get_http_request() is deprecated and will be removed in a future version. "
+            "Use get_http_request() from fastmcp.server.dependencies instead. "
+            "See https://gofastmcp.com/patterns/http-requests for more details.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        return fastmcp.server.dependencies.get_http_request()