fastmcp 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

fastmcp/server/server.py

@@ -1,9 +1,7 @@
 """FastMCP - A more ergonomic interface for MCP servers."""
 
-import inspect
 import json
-import re
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import (
     AbstractAsyncContextManager,
     AsyncExitStack,
@@ -43,8 +41,12 @@ import fastmcp
 import fastmcp.settings
 from fastmcp.exceptions import ResourceError
 from fastmcp.prompts import Prompt, PromptManager
-from fastmcp.resources import FunctionResource, Resource, ResourceManager
+from fastmcp.prompts.prompt import Message, PromptResult
+from fastmcp.resources import Resource, ResourceManager
+from fastmcp.resources.template import ResourceTemplate
 from fastmcp.tools import ToolManager
+from fastmcp.tools.tool import Tool
+from fastmcp.utilities.decorators import DecoratedFunction
 from fastmcp.utilities.logging import configure_logging, get_logger
 from fastmcp.utilities.types import Image
 
@@ -166,22 +168,32 @@ class FastMCP(Generic[LifespanResultT]):
         Args:
             transport: Transport protocol to use ("stdio" or "sse")
         """
+        logger.info(f'Starting server "{self.name}"...')
         anyio.run(self.run_async, transport)
 
     def _setup_handlers(self) -> None:
         """Set up core MCP protocol handlers."""
-        self._mcp_server.list_tools()(self.list_tools)
+        self._mcp_server.list_tools()(self._mcp_list_tools)
         self._mcp_server.call_tool()(self.call_tool)
-        self._mcp_server.list_resources()(self.list_resources)
-        self._mcp_server.read_resource()(self.read_resource)
-        self._mcp_server.list_prompts()(self.list_prompts)
-        self._mcp_server.get_prompt()(self.get_prompt)
-        self._mcp_server.list_resource_templates()(self.list_resource_templates)
+        self._mcp_server.list_resources()(self._mcp_list_resources)
+        self._mcp_server.read_resource()(self._mcp_read_resource)
+        self._mcp_server.list_prompts()(self._mcp_list_prompts)
+        self._mcp_server.get_prompt()(self._mcp_get_prompt)
+        self._mcp_server.list_resource_templates()(self._mcp_list_resource_templates)
 
-    async def list_tools(self) -> list[MCPTool]:
-        """List all available tools."""
+    def list_tools(self) -> list[Tool]:
+        return self._tool_manager.list_tools()
+
+    async def _mcp_list_tools(self) -> list[MCPTool]:
+        """
+        List all available tools, in the format expected by the low-level MCP
+        server.
+
+        See `list_tools` for a more ergonomic way to list tools.
+        """
+
+        tools = self.list_tools()
 
-        tools = self._tool_manager.list_tools()
         return [
             MCPTool(
                 name=info.name,
@@ -214,10 +226,18 @@ class FastMCP(Generic[LifespanResultT]):
         converted_result = _convert_to_content(result)
         return converted_result
 
-    async def list_resources(self) -> list[MCPResource]:
-        """List all available resources."""
+    def list_resources(self) -> list[Resource]:
+        return self._resource_manager.list_resources()
+
+    async def _mcp_list_resources(self) -> list[MCPResource]:
+        """
+        List all available resources, in the format expected by the low-level MCP
+        server.
+
+        See `list_resources` for a more ergonomic way to list resources.
+        """
 
-        resources = self._resource_manager.list_resources()
+        resources = self.list_resources()
         return [
             MCPResource(
                 uri=resource.uri,
@@ -228,8 +248,18 @@ class FastMCP(Generic[LifespanResultT]):
             for resource in resources
         ]
 
-    async def list_resource_templates(self) -> list[MCPResourceTemplate]:
-        templates = self._resource_manager.list_templates()
+    def list_resource_templates(self) -> list[ResourceTemplate]:
+        return self._resource_manager.list_templates()
+
+    async def _mcp_list_resource_templates(self) -> list[MCPResourceTemplate]:
+        """
+        List all available resource templates, in the format expected by the low-level
+        MCP server.
+
+        See `list_resource_templates` for a more ergonomic way to list resource
+        templates.
+        """
+        templates = self.list_resource_templates()
         return [
             MCPResourceTemplate(
                 uriTemplate=template.uri_template,
@@ -239,15 +269,27 @@ class FastMCP(Generic[LifespanResultT]):
             for template in templates
         ]
 
-    async def read_resource(self, uri: AnyUrl | str) -> list[ReadResourceContents]:
+    async def read_resource(self, uri: AnyUrl | str) -> str | bytes:
         """Read a resource by URI."""
+        resource = await self._resource_manager.get_resource(uri)
+        if not resource:
+            raise ResourceError(f"Unknown resource: {uri}")
+        return await resource.read()
+
+    async def _mcp_read_resource(self, uri: AnyUrl | str) -> list[ReadResourceContents]:
+        """
+        Read a resource by URI, in the format expected by the low-level MCP
+        server.
+
+        See `read_resource` for a more ergonomic way to read resources.
+        """
 
         resource = await self._resource_manager.get_resource(uri)
         if not resource:
             raise ResourceError(f"Unknown resource: {uri}")
 
         try:
-            content = await resource.read()
+            content = await self.read_resource(uri)
             return [ReadResourceContents(content=content, mime_type=resource.mime_type)]
         except Exception as e:
             logger.error(f"Error reading resource {uri}: {e}")
@@ -307,6 +349,7 @@ class FastMCP(Generic[LifespanResultT]):
                 await context.report_progress(50, 100)
                 return str(x)
         """
+
         # Check if user passed function directly instead of calling decorator
         if callable(name):
             raise TypeError(
@@ -316,7 +359,7 @@ class FastMCP(Generic[LifespanResultT]):
 
         def decorator(fn: AnyFunction) -> AnyFunction:
             self.add_tool(fn, name=name, description=description, tags=tags)
-            return fn
+            return DecoratedFunction(fn)
 
         return decorator
 
@@ -326,8 +369,40 @@ class FastMCP(Generic[LifespanResultT]):
         Args:
             resource: A Resource instance to add
         """
+
         self._resource_manager.add_resource(resource)
 
+    def add_resource_fn(
+        self,
+        fn: AnyFunction,
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> None:
+        """Add a resource or template to the server from a function.
+
+        If the URI contains parameters (e.g. "resource://{param}") or the function
+        has parameters, it will be registered as a template resource.
+
+        Args:
+            fn: The function to register as a resource
+            uri: The URI for the resource
+            name: Optional name for the resource
+            description: Optional description of the resource
+            mime_type: Optional MIME type for the resource
+            tags: Optional set of tags for categorizing the resource
+        """
+        self._resource_manager.add_resource_or_template_from_fn(
+            fn=fn,
+            uri=uri,
+            name=name,
+            description=description,
+            mime_type=mime_type,
+            tags=tags,
+        )
+
     def resource(
         self,
         uri: str,
@@ -382,52 +457,36 @@ class FastMCP(Generic[LifespanResultT]):
             )
 
         def decorator(fn: AnyFunction) -> AnyFunction:
-            # Check if this should be a template
-            has_uri_params = "{" in uri and "}" in uri
-            has_func_params = bool(inspect.signature(fn).parameters)
-
-            if has_uri_params or has_func_params:
-                # Validate that URI params match function params
-                uri_params = set(re.findall(r"{(\w+)}", uri))
-                func_params = set(inspect.signature(fn).parameters.keys())
-
-                if uri_params != func_params:
-                    raise ValueError(
-                        f"Mismatch between URI parameters {uri_params} "
-                        f"and function parameters {func_params}"
-                    )
-
-                # Register as template
-                self._resource_manager.add_template_from_fn(
-                    fn=fn,
-                    uri_template=uri,
-                    name=name,
-                    description=description,
-                    mime_type=mime_type or "text/plain",
-                    tags=tags,
-                )
-            else:
-                # Register as regular resource
-                resource = FunctionResource(
-                    uri=AnyUrl(uri),
-                    name=name,
-                    description=description,
-                    mime_type=mime_type or "text/plain",
-                    fn=fn,
-                    tags=tags or set(),  # Default to empty set if None
-                )
-                self.add_resource(resource)
-            return fn
+            self._resource_manager.add_resource_or_template_from_fn(
+                fn=fn,
+                uri=uri,
+                name=name,
+                description=description,
+                mime_type=mime_type,
+                tags=tags,
+            )
+            return DecoratedFunction(fn)
 
         return decorator
 
-    def add_prompt(self, prompt: Prompt) -> None:
+    def add_prompt(
+        self,
+        fn: Callable[..., PromptResult | Awaitable[PromptResult]],
+        name: str | None = None,
+        description: str | None = None,
+        tags: set[str] | None = None,
+    ) -> None:
         """Add a prompt to the server.
 
         Args:
             prompt: A Prompt instance to add
         """
-        self._prompt_manager.add_prompt(prompt)
+        self._prompt_manager.add_prompt_from_fn(
+            fn=fn,
+            name=name,
+            description=description,
+            tags=tags,
+        )
 
     def prompt(
         self,
@@ -477,11 +536,8 @@ class FastMCP(Generic[LifespanResultT]):
             )
 
         def decorator(func: AnyFunction) -> AnyFunction:
-            prompt = Prompt.from_function(
-                func, name=name, description=description, tags=tags
-            )
-            self.add_prompt(prompt)
-            return func
+            self.add_prompt(func, name=name, description=description, tags=tags)
+            return DecoratedFunction(func)
 
         return decorator
 
@@ -494,15 +550,20 @@ class FastMCP(Generic[LifespanResultT]):
                 self._mcp_server.create_initialization_options(),
             )
 
-    async def run_sse_async(self) -> None:
+    async def run_sse_async(
+        self,
+        host: str | None = None,
+        port: int | None = None,
+        log_level: str | None = None,
+    ) -> None:
         """Run the server using SSE transport."""
         starlette_app = self.sse_app()
 
         config = uvicorn.Config(
             starlette_app,
-            host=self.settings.host,
-            port=self.settings.port,
-            log_level=self.settings.log_level.lower(),
+            host=host or self.settings.host,
+            port=port or self.settings.port,
+            log_level=log_level or self.settings.log_level.lower(),
         )
         server = uvicorn.Server(config)
         await server.serve()
@@ -531,9 +592,20 @@ class FastMCP(Generic[LifespanResultT]):
             ],
         )
 
-    async def list_prompts(self) -> list[MCPPrompt]:
-        """List all available prompts."""
-        prompts = self._prompt_manager.list_prompts()
+    def list_prompts(self) -> list[Prompt]:
+        """
+        List all available prompts.
+        """
+        return self._prompt_manager.list_prompts()
+
+    async def _mcp_list_prompts(self) -> list[MCPPrompt]:
+        """
+        List all available prompts, in the format expected by the low-level MCP
+        server.
+
+        See `list_prompts` for a more ergonomic way to list prompts.
+        """
+        prompts = self.list_prompts()
         return [
             MCPPrompt(
                 name=prompt.name,
@@ -552,10 +624,21 @@ class FastMCP(Generic[LifespanResultT]):
 
     async def get_prompt(
         self, name: str, arguments: dict[str, Any] | None = None
-    ) -> GetPromptResult:
+    ) -> list[Message]:
         """Get a prompt by name with arguments."""
+        return await self._prompt_manager.render_prompt(name, arguments)
+
+    async def _mcp_get_prompt(
+        self, name: str, arguments: dict[str, Any] | None = None
+    ) -> GetPromptResult:
+        """
+        Get a prompt by name with arguments, in the format expected by the low-level
+        MCP server.
+
+        See `get_prompt` for a more ergonomic way to get prompts.
+        """
         try:
-            messages = await self._prompt_manager.render_prompt(name, arguments)
+            messages = await self.get_prompt(name, arguments)
 
             return GetPromptResult(messages=pydantic_core.to_jsonable_python(messages))
         except Exception as e:

fastmcp/tools/tool.py

@@ -5,7 +5,6 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
 from pydantic import BaseModel, BeforeValidator, Field
-from typing_extensions import Self
 
 from fastmcp.exceptions import ToolError
 from fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
@@ -58,7 +57,10 @@ class Tool(BaseModel):
         is_async = inspect.iscoroutinefunction(fn)
 
         if context_kwarg is None:
-            sig = inspect.signature(fn)
+            if isinstance(fn, classmethod):
+                sig = inspect.signature(fn.__func__)
+            else:
+                sig = inspect.signature(fn)
             for param_name, param in sig.parameters.items():
                 if param.annotation is Context:
                     context_kwarg = param_name
@@ -99,13 +101,6 @@ class Tool(BaseModel):
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
 
-    def copy(self, updates: dict[str, Any] | None = None) -> Self:
-        """Copy the tool with optional updates."""
-        data = self.model_dump()
-        if updates:
-            data.update(updates)
-        return type(self)(**data)
-
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Tool):
             return False

fastmcp/tools/tool_manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import copy
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
@@ -90,7 +91,9 @@ class ToolManager:
         for name, tool in tool_manager._tools.items():
             prefixed_name = f"{prefix}{name}" if prefix else name
 
-            new_tool = tool.copy(updates=dict(name=prefixed_name))
+            new_tool = copy.copy(tool)
+            new_tool.name = prefixed_name
+
             # Store the copied tool
             self.add_tool(new_tool)
             logger.debug(f'Imported tool "{name}" as "{prefixed_name}"')

fastmcp/utilities/decorators.py

@@ -0,0 +1,101 @@
+import inspect
+from collections.abc import Callable
+from typing import Generic, ParamSpec, TypeVar, cast, overload
+
+from typing_extensions import Self
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+class DecoratedFunction(Generic[P, R]):
+    """Descriptor for decorated functions.
+
+    You can return this object from a decorator to ensure that it works across
+    all types of functions: vanilla, instance methods, class methods, and static
+    methods; both synchronous and asynchronous.
+
+    This class is used to store the original function and metadata about how to
+    register it as a tool.
+
+    Example usage:
+
+    ```python
+    def my_decorator(fn: Callable[P, R]) -> DecoratedFunction[P, R]:
+        return DecoratedFunction(fn)
+    ```
+
+    On a function:
+    ```python
+    @my_decorator
+    def my_function(a: int, b: int) -> int:
+        return a + b
+    ```
+
+    On an instance method:
+    ```python
+    class Test:
+        @my_decorator
+        def my_function(self, a: int, b: int) -> int:
+            return a + b
+    ```
+
+    On a class method:
+    ```python
+    class Test:
+        @classmethod
+        @my_decorator
+        def my_function(cls, a: int, b: int) -> int:
+            return a + b
+    ```
+
+    Note that for classmethods, the decorator must be applied first, then
+    `@classmethod` on top.
+
+    On a static method:
+    ```python
+    class Test:
+        @staticmethod
+        @my_decorator
+        def my_function(a: int, b: int) -> int:
+            return a + b
+    ```
+    """
+
+    def __init__(self, fn: Callable[P, R]):
+        self.fn = fn
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        """Call the original function."""
+        try:
+            return self.fn(*args, **kwargs)
+        except TypeError as e:
+            if "'classmethod' object is not callable" in str(e):
+                raise TypeError(
+                    "To apply this decorator to a classmethod, apply the decorator first, then @classmethod on top."
+                )
+            raise
+
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Self: ...
+
+    @overload
+    def __get__(
+        self, instance: object, owner: type | None = None
+    ) -> Callable[P, R]: ...
+
+    def __get__(
+        self, instance: object | None, owner: type | None = None
+    ) -> Self | Callable[P, R]:
+        """Return the original function when accessed from an instance, or self when accessed from the class."""
+        if instance is None:
+            return self
+        # Return the original function bound to the instance
+        return cast(Callable[P, R], self.fn.__get__(instance, owner))
+
+    def __repr__(self) -> str:
+        """Return a representation that matches Python's function representation."""
+        module = getattr(self.fn, "__module__", "unknown")
+        qualname = getattr(self.fn, "__qualname__", str(self.fn))
+        sig_str = str(inspect.signature(self.fn))
+        return f"<function {module}.{qualname}{sig_str}>"

fastmcp/utilities/func_metadata.py

@@ -125,7 +125,10 @@ def func_metadata(
     Returns:
         A pydantic model representing the function's signature.
     """
-    sig = _get_typed_signature(func)
+    if isinstance(func, classmethod):
+        sig = _get_typed_signature(func.__func__)
+    else:
+        sig = _get_typed_signature(func)
     params = sig.parameters
     dynamic_pydantic_model_params: dict[str, Any] = {}
     globalns = getattr(func, "__globals__", {})

fastmcp/utilities/logging.py

@@ -20,15 +20,23 @@ def get_logger(name: str) -> logging.Logger:
 
 
 def configure_logging(
-    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO",
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
 ) -> None:
     """Configure logging for FastMCP.
 
     Args:
         level: the log level to use
     """
-    logging.basicConfig(
-        level=level,
-        format="%(message)s",
-        handlers=[RichHandler(console=Console(stderr=True), rich_tracebacks=True)],
-    )
+    # Only configure the FastMCP logger namespace
+    handler = RichHandler(console=Console(stderr=True), rich_tracebacks=True)
+    formatter = logging.Formatter("%(message)s")
+    handler.setFormatter(formatter)
+
+    fastmcp_logger = logging.getLogger("FastMCP")
+    fastmcp_logger.setLevel(level)
+
+    # Remove any existing handlers to avoid duplicates on reconfiguration
+    for hdlr in fastmcp_logger.handlers[:]:
+        fastmcp_logger.removeHandler(hdlr)
+
+    fastmcp_logger.addHandler(handler)