fastmcp 2.6.1__py3-none-any.whl → 2.7.1__py3-none-any.whl

fastmcp/cli/cli.py

@@ -1,4 +1,4 @@
-"""FastmMCP CLI tools."""
+"""FastMCP CLI tools."""
 
 import importlib.metadata
 import importlib.util
@@ -219,8 +219,9 @@ def dev(
         sys.exit(1)
 
 
-@app.command()
+@app.command(context_settings={"allow_extra_args": True})
 def run(
+    ctx: typer.Context,
     server_spec: str = typer.Argument(
         ...,
         help="Python file, object specification (file:obj), or URL",
@@ -266,7 +267,12 @@ def run(
 
     Note: This command runs the server directly. You are responsible for ensuring
     all dependencies are available.
+
+    Server arguments can be passed after -- :
+    fastmcp run server.py -- --config config.json --debug
     """
+    server_args = ctx.args  # extra args after --
+
     logger.debug(
         "Running server or client",
         extra={
@@ -275,6 +281,7 @@ def run(
             "host": host,
             "port": port,
             "log_level": log_level,
+            "server_args": server_args,
         },
     )
 
@@ -285,6 +292,7 @@ def run(
             host=host,
             port=port,
             log_level=log_level,
+            server_args=server_args,
         )
     except Exception as e:
         logger.error(

fastmcp/cli/run.py

@@ -71,6 +71,9 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
         logger.error("Could not load module", extra={"file": str(file)})
         sys.exit(1)
 
+    assert spec is not None
+    assert spec.loader is not None
+
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
 
@@ -89,6 +92,8 @@ def import_server(file: Path, server_object: str | None = None) -> Any:
         )
         sys.exit(1)
 
+    assert server_object is not None
+
     # Handle module:object syntax
     if ":" in server_object:
         module_name, object_name = server_object.split(":", 1)
@@ -135,12 +140,37 @@ def create_client_server(url: str) -> Any:
         sys.exit(1)
 
 
+def import_server_with_args(
+    file: Path, server_object: str | None = None, server_args: list[str] | None = None
+) -> Any:
+    """Import a server with optional command line arguments.
+
+    Args:
+        file: Path to the server file
+        server_object: Optional server object name
+        server_args: Optional command line arguments to inject
+
+    Returns:
+        The imported server object
+    """
+    if server_args:
+        original_argv = sys.argv[:]
+        try:
+            sys.argv = [str(file)] + server_args
+            return import_server(file, server_object)
+        finally:
+            sys.argv = original_argv
+    else:
+        return import_server(file, server_object)
+
+
 def run_command(
     server_spec: str,
     transport: str | None = None,
     host: str | None = None,
     port: int | None = None,
     log_level: str | None = None,
+    server_args: list[str] | None = None,
 ) -> None:
     """Run a MCP server or connect to a remote one.
 
@@ -150,6 +180,7 @@ def run_command(
         host: Host to bind to when using http transport
         port: Port to bind to when using http transport
         log_level: Log level
+        server_args: Additional arguments to pass to the server
     """
     if is_url(server_spec):
         # Handle URL case
@@ -158,7 +189,7 @@ def run_command(
     else:
         # Handle file case
         file, server_object = parse_file_path(server_spec)
-        server = import_server(file, server_object)
+        server = import_server_with_args(file, server_object, server_args)
         logger.debug(f'Found server "{server.name}" in {file}')
 
     # Run the server

fastmcp/client/transports.py

@@ -27,15 +27,12 @@ from mcp.client.session import (
     MessageHandlerFnT,
     SamplingFnT,
 )
-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.server.fastmcp import FastMCP as FastMCP1Server
 from mcp.shared.memory import create_connected_server_and_client_session
 from pydantic import AnyUrl
 from typing_extensions import Unpack
 
+from fastmcp.client.auth.bearer import BearerAuth
 from fastmcp.client.auth.oauth import OAuth
 from fastmcp.server.dependencies import get_http_headers
 from fastmcp.server.server import FastMCP
@@ -141,6 +138,13 @@ class WSTransport(ClientTransport):
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
+        try:
+            from mcp.client.websocket import websocket_client
+        except ImportError:
+            raise ImportError(
+                "The websocket transport is not available. Please install fastmcp[websockets] or install the websockets package manually."
+            )
+
         async with websocket_client(self.url) as transport:
             read_stream, write_stream = transport
             async with ClientSession(
@@ -149,7 +153,7 @@ class WSTransport(ClientTransport):
                 yield session
 
     def __repr__(self) -> str:
-        return f"<WebSocket(url='{self.url}')>"
+        return f"<WebSocketTransport(url='{self.url}')>"
 
 
 class SSETransport(ClientTransport):
@@ -180,14 +184,15 @@ class SSETransport(ClientTransport):
         if auth == "oauth":
             auth = OAuth(self.url)
         elif isinstance(auth, str):
-            self.headers["Authorization"] = auth
-            auth = None
+            auth = BearerAuth(auth)
         self.auth = auth
 
     @contextlib.asynccontextmanager
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
+        from mcp.client.sse import sse_client
+
         client_kwargs: dict[str, Any] = {}
 
         # load headers from an active HTTP request, if available. This will only be true
@@ -216,7 +221,7 @@ class SSETransport(ClientTransport):
                 yield session
 
     def __repr__(self) -> str:
-        return f"<SSE(url='{self.url}')>"
+        return f"<SSETransport(url='{self.url}')>"
 
 
 class StreamableHttpTransport(ClientTransport):
@@ -247,14 +252,15 @@ class StreamableHttpTransport(ClientTransport):
         if auth == "oauth":
             auth = OAuth(self.url)
         elif isinstance(auth, str):
-            self.headers["Authorization"] = auth
-            auth = None
+            auth = BearerAuth(auth)
         self.auth = auth
 
     @contextlib.asynccontextmanager
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
+        from mcp.client.streamable_http import streamablehttp_client
+
         client_kwargs: dict[str, Any] = {}
 
         # load headers from an active HTTP request, if available. This will only be true
@@ -284,7 +290,7 @@ class StreamableHttpTransport(ClientTransport):
                 yield session
 
     def __repr__(self) -> str:
-        return f"<StreamableHttp(url='{self.url}')>"
+        return f"<StreamableHttpTransport(url='{self.url}')>"
 
 
 class StdioTransport(ClientTransport):
@@ -350,6 +356,8 @@ class StdioTransport(ClientTransport):
             return
 
         async def _connect_task():
+            from mcp.client.stdio import stdio_client
+
             async with contextlib.AsyncExitStack() as stack:
                 try:
                     server_params = StdioServerParameters(
@@ -674,7 +682,7 @@ class FastMCPTransport(ClientTransport):
             yield session
 
     def __repr__(self) -> str:
-        return f"<FastMCP(server='{self.server.name}')>"
+        return f"<FastMCPTransport(server='{self.server.name}')>"
 
 
 class MCPConfigTransport(ClientTransport):
@@ -760,7 +768,7 @@ class MCPConfigTransport(ClientTransport):
             yield session
 
     def __repr__(self) -> str:
-        return f"<MCPConfig(config='{self.config}')>"
+        return f"<MCPConfigTransport(config='{self.config}')>"
 
 
 @overload

fastmcp/contrib/bulk_tool_caller/example.py

@@ -6,7 +6,7 @@ from fastmcp.contrib.bulk_tool_caller import BulkToolCaller
 mcp = FastMCP()
 
 
-@mcp.tool()
+@mcp.tool
 def echo_tool(text: str) -> str:
     """Echo the input text"""
     return text

fastmcp/contrib/mcp_mixin/mcp_mixin.py

@@ -3,6 +3,10 @@
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
+from fastmcp.prompts.prompt import Prompt
+from fastmcp.resources.resource import Resource
+from fastmcp.tools.tool import Tool
+
 if TYPE_CHECKING:
     from fastmcp.server import FastMCP
 
@@ -128,7 +132,8 @@ class MCPMixin:
                 registration_info["name"] = (
                     f"{prefix}{separator}{registration_info['name']}"
                 )
-            mcp_server.add_tool(fn=method, **registration_info)
+            tool = Tool.from_function(fn=method, **registration_info)
+            mcp_server.add_tool(tool)
 
     def register_resources(
         self,
@@ -156,7 +161,8 @@ class MCPMixin:
                 registration_info["uri"] = (
                     f"{prefix}{separator}{registration_info['uri']}"
                 )
-            mcp_server.add_resource_fn(fn=method, **registration_info)
+            resource = Resource.from_function(fn=method, **registration_info)
+            mcp_server.add_resource(resource)
 
     def register_prompts(
         self,
@@ -180,7 +186,8 @@ class MCPMixin:
                 registration_info["name"] = (
                     f"{prefix}{separator}{registration_info['name']}"
                 )
-            mcp_server.add_prompt(fn=method, **registration_info)
+            prompt = Prompt.from_function(fn=method, **registration_info)
+            mcp_server.add_prompt(prompt)
 
     def register_all(
         self,

fastmcp/prompts/prompt.py

@@ -3,6 +3,7 @@
 from __future__ import annotations as _annotations
 
 import inspect
+from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Sequence
 from typing import TYPE_CHECKING, Annotated, Any
 
@@ -10,13 +11,14 @@ import pydantic_core
 from mcp.types import EmbeddedResource, ImageContent, PromptMessage, Role, TextContent
 from mcp.types import Prompt as MCPPrompt
 from mcp.types import PromptArgument as MCPPromptArgument
-from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
+from pydantic import BeforeValidator, Field, TypeAdapter, validate_call
 
 from fastmcp.exceptions import PromptError
 from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.json_schema import compress_schema
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import (
+    FastMCPBaseModel,
     _convert_set_defaults,
     find_kwarg_by_type,
     get_cached_typeadapter,
@@ -52,31 +54,86 @@ SyncPromptResult = (
 PromptResult = SyncPromptResult | Awaitable[SyncPromptResult]
 
 
-class PromptArgument(BaseModel):
+class PromptArgument(FastMCPBaseModel):
     """An argument that can be passed to a prompt."""
 
     name: str = Field(description="Name of the argument")
     description: str | None = Field(
-        None, description="Description of what the argument does"
+        default=None, description="Description of what the argument does"
     )
     required: bool = Field(
         default=False, description="Whether the argument is required"
     )
 
 
-class Prompt(BaseModel):
+class Prompt(FastMCPBaseModel, ABC):
     """A prompt template that can be rendered with parameters."""
 
     name: str = Field(description="Name of the prompt")
     description: str | None = Field(
-        None, description="Description of what the prompt does"
+        default=None, description="Description of what the prompt does"
     )
     tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
         default_factory=set, description="Tags for the prompt"
     )
     arguments: list[PromptArgument] | None = Field(
-        None, description="Arguments that can be passed to the prompt"
+        default=None, description="Arguments that can be passed to the prompt"
     )
+
+    def __eq__(self, other: object) -> bool:
+        if type(self) is not type(other):
+            return False
+        assert isinstance(other, type(self))
+        return self.model_dump() == other.model_dump()
+
+    def to_mcp_prompt(self, **overrides: Any) -> MCPPrompt:
+        """Convert the prompt to an MCP prompt."""
+        arguments = [
+            MCPPromptArgument(
+                name=arg.name,
+                description=arg.description,
+                required=arg.required,
+            )
+            for arg in self.arguments or []
+        ]
+        kwargs = {
+            "name": self.name,
+            "description": self.description,
+            "arguments": arguments,
+        }
+        return MCPPrompt(**kwargs | overrides)
+
+    @staticmethod
+    def from_function(
+        fn: Callable[..., PromptResult | Awaitable[PromptResult]],
+        name: str | None = None,
+        description: str | None = None,
+        tags: set[str] | None = None,
+    ) -> FunctionPrompt:
+        """Create a Prompt from a function.
+
+        The function can return:
+        - A string (converted to a message)
+        - A Message object
+        - A dict (converted to a message)
+        - A sequence of any of the above
+        """
+        return FunctionPrompt.from_function(
+            fn=fn, name=name, description=description, tags=tags
+        )
+
+    @abstractmethod
+    async def render(
+        self,
+        arguments: dict[str, Any] | None = None,
+    ) -> list[PromptMessage]:
+        """Render the prompt with arguments."""
+        raise NotImplementedError("Prompt.render() must be implemented by subclasses")
+
+
+class FunctionPrompt(Prompt):
+    """A prompt that is a function."""
+
     fn: Callable[..., PromptResult | Awaitable[PromptResult]]
 
     @classmethod
@@ -86,7 +143,7 @@ class Prompt(BaseModel):
         name: str | None = None,
         description: str | None = None,
         tags: set[str] | None = None,
-    ) -> Prompt:
+    ) -> FunctionPrompt:
         """Create a Prompt from a function.
 
         The function can return:
@@ -114,6 +171,9 @@ class Prompt(BaseModel):
         # if the fn is a callable class, we need to get the __call__ method from here out
         if not inspect.isroutine(fn):
             fn = fn.__call__
+        # if the fn is a staticmethod, we need to work with the underlying function
+        if isinstance(fn, staticmethod):
+            fn = fn.__func__
 
         type_adapter = get_cached_typeadapter(fn)
         parameters = type_adapter.json_schema()
@@ -147,8 +207,8 @@ class Prompt(BaseModel):
             name=func_name,
             description=description,
             arguments=arguments,
-            fn=fn,
             tags=tags or set(),
+            fn=fn,
         )
 
     async def render(
@@ -212,25 +272,3 @@ class Prompt(BaseModel):
         except Exception as e:
             logger.exception(f"Error rendering prompt {self.name}: {e}")
             raise PromptError(f"Error rendering prompt {self.name}.")
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Prompt):
-            return False
-        return self.model_dump() == other.model_dump()
-
-    def to_mcp_prompt(self, **overrides: Any) -> MCPPrompt:
-        """Convert the prompt to an MCP prompt."""
-        arguments = [
-            MCPPromptArgument(
-                name=arg.name,
-                description=arg.description,
-                required=arg.required,
-            )
-            for arg in self.arguments or []
-        ]
-        kwargs = {
-            "name": self.name,
-            "description": self.description,
-            "arguments": arguments,
-        }
-        return MCPPrompt(**kwargs | overrides)

fastmcp/prompts/prompt_manager.py

@@ -1,14 +1,13 @@
-"""Prompt management functionality."""
-
 from __future__ import annotations as _annotations
 
+import warnings
 from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any
 
 from mcp import GetPromptResult
 
 from fastmcp.exceptions import NotFoundError, PromptError
-from fastmcp.prompts.prompt import Prompt, PromptResult
+from fastmcp.prompts.prompt import FunctionPrompt, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
@@ -55,10 +54,18 @@ class PromptManager:
         name: str | None = None,
         description: str | None = None,
         tags: set[str] | None = None,
-    ) -> Prompt:
+    ) -> FunctionPrompt:
         """Create a prompt from a function."""
-        prompt = Prompt.from_function(fn, name=name, description=description, tags=tags)
-        return self.add_prompt(prompt)
+        # deprecated in 2.7.0
+        warnings.warn(
+            "PromptManager.add_prompt_from_fn() is deprecated. Use Prompt.from_function() and call add_prompt() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        prompt = FunctionPrompt.from_function(
+            fn, name=name, description=description, tags=tags
+        )
+        return self.add_prompt(prompt)  # type: ignore
 
     def add_prompt(self, prompt: Prompt, key: str | None = None) -> Prompt:
         """Add a prompt to the manager."""

fastmcp/resources/__init__.py

@@ -1,10 +1,9 @@
-from .resource import Resource
+from .resource import FunctionResource, Resource
 from .template import ResourceTemplate
 from .types import (
     BinaryResource,
     DirectoryResource,
     FileResource,
-    FunctionResource,
     HttpResource,
     TextResource,
 )

fastmcp/resources/resource.py

@@ -3,12 +3,14 @@
 from __future__ import annotations
 
 import abc
+import inspect
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
+import pydantic_core
 from mcp.types import Resource as MCPResource
 from pydantic import (
     AnyUrl,
-    BaseModel,
     BeforeValidator,
     ConfigDict,
     Field,
@@ -17,13 +19,18 @@ from pydantic import (
     field_validator,
 )
 
-from fastmcp.utilities.types import _convert_set_defaults
+from fastmcp.server.dependencies import get_context
+from fastmcp.utilities.types import (
+    FastMCPBaseModel,
+    _convert_set_defaults,
+    find_kwarg_by_type,
+)
 
 if TYPE_CHECKING:
     pass
 
 
-class Resource(BaseModel, abc.ABC):
+class Resource(FastMCPBaseModel, abc.ABC):
     """Base class for all resources."""
 
     model_config = ConfigDict(validate_default=True)
@@ -31,9 +38,9 @@ class Resource(BaseModel, abc.ABC):
     uri: Annotated[AnyUrl, UrlConstraints(host_required=False)] = Field(
         default=..., description="URI of the resource"
     )
-    name: str | None = Field(description="Name of the resource", default=None)
+    name: str | None = Field(default=None, description="Name of the resource")
     description: str | None = Field(
-        description="Description of the resource", default=None
+        default=None, description="Description of the resource"
     )
     tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
         default_factory=set, description="Tags for the resource"
@@ -44,6 +51,24 @@ class Resource(BaseModel, abc.ABC):
         pattern=r"^[a-zA-Z0-9]+/[a-zA-Z0-9\-+.]+$",
     )
 
+    @staticmethod
+    def from_function(
+        fn: Callable[[], Any],
+        uri: str | AnyUrl,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> FunctionResource:
+        return FunctionResource.from_function(
+            fn=fn,
+            uri=uri,
+            name=name,
+            description=description,
+            mime_type=mime_type,
+            tags=tags,
+        )
+
     @field_validator("mime_type", mode="before")
     @classmethod
     def set_default_mime_type(cls, mime_type: str | None) -> str:
@@ -68,8 +93,9 @@ class Resource(BaseModel, abc.ABC):
         pass
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Resource):
+        if type(self) is not type(other):
             return False
+        assert isinstance(other, type(self))
         return self.model_dump() == other.model_dump()
 
     def to_mcp_resource(self, **overrides: Any) -> MCPResource:
@@ -81,3 +107,63 @@ class Resource(BaseModel, abc.ABC):
             "mimeType": self.mime_type,
         }
         return MCPResource(**kwargs | overrides)
+
+
+class FunctionResource(Resource):
+    """A resource that defers data loading by wrapping a function.
+
+    The function is only called when the resource is read, allowing for lazy loading
+    of potentially expensive data. This is particularly useful when listing resources,
+    as the function won't be called until the resource is actually accessed.
+
+    The function can return:
+    - str for text content (default)
+    - bytes for binary content
+    - other types will be converted to JSON
+    """
+
+    fn: Callable[[], Any]
+
+    @classmethod
+    def from_function(
+        cls,
+        fn: Callable[[], Any],
+        uri: str | AnyUrl,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> FunctionResource:
+        """Create a FunctionResource from a function."""
+        if isinstance(uri, str):
+            uri = AnyUrl(uri)
+        return cls(
+            fn=fn,
+            uri=uri,
+            name=name or fn.__name__,
+            description=description or fn.__doc__,
+            mime_type=mime_type or "text/plain",
+            tags=tags or set(),
+        )
+
+    async def read(self) -> str | bytes:
+        """Read the resource by calling the wrapped function."""
+        from fastmcp.server.context import Context
+
+        kwargs = {}
+        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()
+        elif isinstance(result, bytes):
+            return result
+        elif isinstance(result, str):
+            return result
+        else:
+            return pydantic_core.to_json(result, fallback=str, indent=2).decode()