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

fastmcp/cli/cli.py

@@ -323,6 +323,8 @@ def run(
         # Import and get server object
         server = _import_server(file, server_object)
 
+        logger.info(f'Found server "{server.name}" in {file}')
+
         # Run the server
         kwargs = {}
         if transport:

fastmcp/client/transports.py

@@ -208,6 +208,28 @@ class PythonStdioTransport(StdioTransport):
         self.script_path = script_path
 
 
+class FastMCPStdioTransport(StdioTransport):
+    """Transport for running FastMCP servers using the FastMCP CLI."""
+
+    def __init__(
+        self,
+        script_path: str | Path,
+        args: list[str] | None = None,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ):
+        script_path = Path(script_path).resolve()
+        if not script_path.is_file():
+            raise FileNotFoundError(f"Script not found: {script_path}")
+        if not str(script_path).endswith(".py"):
+            raise ValueError(f"Not a Python script: {script_path}")
+
+        super().__init__(
+            command="fastmcp", args=["run", str(script_path)], env=env, cwd=cwd
+        )
+        self.script_path = script_path
+
+
 class NodeStdioTransport(StdioTransport):
     """Transport for running Node.js scripts."""
 

fastmcp/exceptions.py

@@ -17,5 +17,9 @@ class ToolError(FastMCPError):
     """Error in tool operations."""
 
 
+class PromptError(FastMCPError):
+    """Error in prompt operations."""
+
+
 class InvalidSignature(Exception):
     """Invalid signature for use with FastMCP."""

fastmcp/prompts/__init__.py

@@ -1,4 +1,4 @@
-from .prompt import Prompt
+from .prompt import Prompt, Message, UserMessage, AssistantMessage
 from .prompt_manager import PromptManager
 
-__all__ = ["Prompt", "PromptManager"]
+__all__ = ["Prompt", "PromptManager", "Message", "UserMessage", "AssistantMessage"]

fastmcp/prompts/prompt.py

@@ -27,27 +27,17 @@ class Message(BaseModel):
         super().__init__(content=content, **kwargs)
 
 
-class UserMessage(Message):
+def UserMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
     """A message from the user."""
+    return Message(content=content, role="user", **kwargs)
 
-    role: Literal["user", "assistant"] = "user"
 
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        super().__init__(content=content, **kwargs)
-
-
-class AssistantMessage(Message):
+def AssistantMessage(content: str | CONTENT_TYPES, **kwargs: Any) -> Message:
     """A message from the assistant."""
+    return Message(content=content, role="assistant", **kwargs)
 
-    role: Literal["user", "assistant"] = "assistant"
-
-    def __init__(self, content: str | CONTENT_TYPES, **kwargs: Any):
-        super().__init__(content=content, **kwargs)
 
-
-message_validator = TypeAdapter[UserMessage | AssistantMessage](
-    UserMessage | AssistantMessage
-)
+message_validator = TypeAdapter[Message](Message)
 
 SyncPromptResult = (
     str | Message | dict[str, Any] | Sequence[str | Message | dict[str, Any]]
@@ -160,7 +150,7 @@ class Prompt(BaseModel):
                         messages.append(message_validator.validate_python(msg))
                     elif isinstance(msg, str):
                         content = TextContent(type="text", text=msg)
-                        messages.append(UserMessage(content=content))
+                        messages.append(Message(role="user", content=content))
                     else:
                         content = json.dumps(pydantic_core.to_jsonable_python(msg))
                         messages.append(Message(role="user", content=content))

fastmcp/prompts/prompt_manager.py

@@ -3,6 +3,7 @@
 from collections.abc import Awaitable, Callable
 from typing import Any
 
+from fastmcp.exceptions import PromptError
 from fastmcp.prompts.prompt import Message, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -61,7 +62,7 @@ class PromptManager:
         """Render a prompt by name with arguments."""
         prompt = self.get_prompt(name)
         if not prompt:
-            raise ValueError(f"Unknown prompt: {name}")
+            raise PromptError(f"Unknown prompt: {name}")
 
         return await prompt.render(arguments)
 

fastmcp/resources/__init__.py

@@ -1,5 +1,4 @@
 from .resource import Resource
-from .resource_manager import ResourceManager
 from .template import ResourceTemplate
 from .types import (
     BinaryResource,
@@ -9,6 +8,7 @@ from .types import (
     HttpResource,
     TextResource,
 )
+from .resource_manager import ResourceManager
 
 __all__ = [
     "Resource",

fastmcp/resources/resource_manager.py

@@ -1,11 +1,14 @@
 """Resource manager functionality."""
 
+import inspect
+import re
 from collections.abc import Callable
 from typing import Any
 
 from pydantic import AnyUrl
 
-from fastmcp.resources.resource import Resource
+from fastmcp.exceptions import ResourceError
+from fastmcp.resources import FunctionResource, Resource
 from fastmcp.resources.template import ResourceTemplate
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -21,16 +24,86 @@ class ResourceManager:
         self._templates: dict[str, ResourceTemplate] = {}
         self.duplicate_behavior = duplicate_behavior
 
-    def add_resource(self, resource: Resource) -> Resource:
-        """Add a resource to the manager.
+    def add_resource_or_template_from_fn(
+        self,
+        fn: Callable[..., Any],
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Resource | ResourceTemplate:
+        """Add a resource or template to the manager from a function.
 
         Args:
-            resource: A Resource instance to add
+            fn: The function to register as a resource or template
+            uri: The URI for the resource or template
+            name: Optional name for the resource or template
+            description: Optional description of the resource or template
+            mime_type: Optional MIME type for the resource or template
+            tags: Optional set of tags for categorizing the resource or template
+
+        Returns:
+            The added resource or template. If a resource or template with the same URI already exists,
+            returns the existing resource or template.
+        """
+        # 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 and has_func_params:
+            return self.add_template_from_fn(
+                fn, uri, name, description, mime_type, tags
+            )
+        elif not has_uri_params and not has_func_params:
+            return self.add_resource_from_fn(
+                fn, uri, name, description, mime_type, tags
+            )
+        else:
+            raise ValueError(
+                "Invalid resource or template definition due to a "
+                "mismatch between URI parameters and function parameters."
+            )
+
+    def add_resource_from_fn(
+        self,
+        fn: Callable[..., Any],
+        uri: str,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Resource:
+        """Add a resource to the manager from a function.
+
+        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
 
         Returns:
             The added resource. If a resource with the same URI already exists,
             returns the existing resource.
         """
+        resource = FunctionResource(
+            uri=AnyUrl(uri),
+            name=name,
+            description=description,
+            mime_type=mime_type or "text/plain",
+            fn=fn,
+            tags=tags or set(),
+        )
+        return self.add_resource(resource)
+
+    def add_resource(self, resource: Resource) -> Resource:
+        """Add a resource to the manager.
+
+        Args:
+            resource: A Resource instance to add
+        """
         logger.debug(
             "Adding resource",
             extra={
@@ -63,6 +136,17 @@ class ResourceManager:
         tags: set[str] | None = None,
     ) -> ResourceTemplate:
         """Create a template from a function."""
+
+        # Validate that URI params match function params
+        uri_params = set(re.findall(r"{(\w+)}", uri_template))
+        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}"
+            )
+
         template = ResourceTemplate.from_function(
             fn,
             uri_template=uri_template,
@@ -122,7 +206,7 @@ class ResourceManager:
                 except Exception as e:
                     raise ValueError(f"Error creating resource from template: {e}")
 
-        raise ValueError(f"Unknown resource: {uri}")
+        raise ResourceError(f"Unknown resource: {uri}")
 
     def list_resources(self) -> list[Resource]:
         """List all registered resources."""

fastmcp/server/context.py

@@ -118,7 +118,7 @@ class Context(BaseModel, Generic[ServerSessionT, LifespanContextT]):
         assert self._fastmcp is not None, (
             "Context is not available outside of a request"
         )
-        return await self._fastmcp.read_resource(uri)
+        return await self._fastmcp._mcp_read_resource(uri)
 
     async def log(
         self,

fastmcp/server/proxy.py

@@ -1,11 +1,11 @@
 from typing import Any, cast
 
 import mcp.types
-from mcp.types import BlobResourceContents, PromptMessage, TextResourceContents
+from mcp.types import BlobResourceContents, TextResourceContents
 
 import fastmcp
 from fastmcp.client import Client
-from fastmcp.prompts import Prompt
+from fastmcp.prompts import Message, Prompt
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.context import Context
 from fastmcp.server.server import FastMCP
@@ -142,10 +142,10 @@ class ProxyPrompt(Prompt):
             fn=_proxy_passthrough,
         )
 
-    async def render(self, arguments: dict[str, Any]) -> list[PromptMessage]:
+    async def render(self, arguments: dict[str, Any]) -> list[Message]:
         async with self._client:
             result = await self._client.get_prompt(self.name, arguments)
-        return result.messages
+        return [Message(role=m.role, content=m.content) for m in result.messages]
 
 
 class FastMCPProxy(FastMCP):

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

@@ -58,7 +58,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