fastmcp 2.3.1__tar.gz → 2.3.3__tar.gz

{fastmcp-2.3.1 → fastmcp-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.3.1
+Version: 2.3.3
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 > [!NOTE]
 > #### FastMCP 2.0 & The Official MCP SDK
 >
-> Recognize the `FastMCP` name? You might have used the version integrated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
+> Recognize the `FastMCP` name? You might have seen the version that was contributed to the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
 >
 > **Welcome to FastMCP 2.0!** This is the actively developed successor, and it significantly expands on 1.0 by introducing powerful client capabilities, server proxying & composition, OpenAPI/FastAPI integration, and more advanced features.
 >

{fastmcp-2.3.1 → fastmcp-2.3.3}/README.md

@@ -15,7 +15,7 @@
 > [!NOTE]
 > #### FastMCP 2.0 & The Official MCP SDK
 >
-> Recognize the `FastMCP` name? You might have used the version integrated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
+> Recognize the `FastMCP` name? You might have seen the version that was contributed to the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
 >
 > **Welcome to FastMCP 2.0!** This is the actively developed successor, and it significantly expands on 1.0 by introducing powerful client capabilities, server proxying & composition, OpenAPI/FastAPI integration, and more advanced features.
 >

{fastmcp-2.3.1 → fastmcp-2.3.3}/docs/deployment/asgi.mdx

@@ -5,6 +5,9 @@ description: Integrate FastMCP servers into existing Starlette, FastAPI, or othe
 icon: plug
 ---
 
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+
 While FastMCP provides standalone server capabilities, you can also integrate your FastMCP server into existing web applications. This approach is useful for:
 
 - Adding MCP functionality to an existing website or API
@@ -16,10 +19,13 @@ Please note that all FastMCP servers have a `run()` method that can be used to s
 
 ## ASGI Server
 
-
 FastMCP servers can be created as [Starlette](https://www.starlette.io/) ASGI apps for straightforward hosting or integration into existing applications.
 
-The first step is to obtain a Starlette application instance from your FastMCP server using either the `streamable_http_app()` (preferred) or `sse_app()` (legacy) methods:
+The first step is to obtain a Starlette application instance from your FastMCP server using the `http_app()` method:
+
+<Tip>
+The `http_app()` method is new in FastMCP 2.3.2. In older versions, use `sse_app()` for SSE transport or `streamable_http_app()` for Streamable HTTP transport.
+</Tip>
 
 ```python
 from fastmcp import FastMCP
@@ -30,18 +36,23 @@ mcp = FastMCP("MyServer")
 def hello(name: str) -> str:
     return f"Hello, {name}!"
 
-# Get a Starlette app instance for the preferred transport
-http_app = mcp.streamable_http_app()   # For Streamable HTTP transport
-sse_app = mcp.sse_app()                # For SSE transport
+# Get a Starlette app instance for Streamable HTTP transport (recommended)
+http_app = mcp.http_app()
+
+# For legacy SSE transport (deprecated)
+sse_app = mcp.http_app(transport="sse")
 ```
 
-Both methods return a Starlette application that can be integrated with other ASGI-compatible web frameworks. 
+Both approaches return a Starlette application that can be integrated with other ASGI-compatible web frameworks. 
 
-The MCP server's endpoint is mounted at the root path `/mcp` for Streamable HTTP transport, and `/sse` for SSE transport, though you can change these paths by passing a `path` argument to the `streamable_http_app()` or `sse_app()` methods:
+The MCP server's endpoint is mounted at the root path `/mcp` for Streamable HTTP transport, and `/sse` for SSE transport, though you can change these paths by passing a `path` argument to the `http_app()` method:
 
 ```python
-http_app = mcp.streamable_http_app(path="/custom-mcp-path")
-sse_app = mcp.sse_app(path="/custom-sse-path")
+# For Streamable HTTP transport
+http_app = mcp.http_app(path="/custom-mcp-path")
+
+# For SSE transport (deprecated)
+sse_app = mcp.http_app(path="/custom-sse-path", transport="sse")
 ```
 
 ### Running the Server
@@ -49,9 +60,12 @@ sse_app = mcp.sse_app(path="/custom-sse-path")
 To run the FastMCP server, you can use the `uvicorn` ASGI server:
 
 ```python
+from fastmcp import FastMCP
 import uvicorn
 
-# (define the app here)
+mcp = FastMCP("MyServer")
+
+http_app = mcp.http_app()
 
 if __name__ == "__main__":
     uvicorn.run(http_app, host="0.0.0.0", port=8000)
@@ -63,11 +77,35 @@ Or, from the command line:
 uvicorn path.to.your.app:http_app --host 0.0.0.0 --port 8000
 ```
 
+### Custom Middleware
+
+<VersionBadge version="2.3.2" />
+
+You can add custom Starlette middleware to your FastMCP ASGI apps by passing a list of middleware instances to the app creation methods:
+
+```python
+from fastmcp import FastMCP
+from starlette.middleware import Middleware
+from starlette.middleware.cors import CORSMiddleware
+
+# Create your FastMCP server
+mcp = FastMCP("MyServer")
+
+# Define custom middleware
+custom_middleware = [
+    Middleware(CORSMiddleware, allow_origins=["*"]),
+]
+
+# Create ASGI app with custom middleware
+http_app = mcp.http_app(middleware=custom_middleware)
+```
 
 
 ## Starlette Integration
 
-You can mount your FastMCP server in another Starlette application using the `Mount` class.
+<VersionBadge version="2.3.1" />
+
+You can mount your FastMCP server in another Starlette application:
 
 ```python
 from fastmcp import FastMCP
@@ -78,7 +116,7 @@ from starlette.routing import Mount
 mcp = FastMCP("MyServer")
 
 # Create the ASGI app
-mcp_app = mcp.streamable_http_app(path='/mcp')
+mcp_app = mcp.http_app(path='/mcp')
 
 # Create a Starlette app and mount the MCP server
 app = Starlette(
@@ -110,7 +148,7 @@ from starlette.routing import Mount
 mcp = FastMCP("MyServer")
 
 # Create the ASGI app
-mcp_app = mcp.streamable_http_app(path='/mcp')
+mcp_app = mcp.http_app(path='/mcp')
 
 # Create nested application structure
 inner_app = Starlette(routes=[Mount("/inner", app=mcp_app)])
@@ -127,6 +165,8 @@ For Streamable HTTP transport, you **must** pass the lifespan context from the F
 </Warning>
 ## FastAPI Integration
 
+<VersionBadge version="2.3.1" />
+
 FastAPI is built on Starlette, so you can mount your FastMCP server in a similar way:
 
 ```python
@@ -138,7 +178,7 @@ from starlette.routing import Mount
 mcp = FastMCP("MyServer")
 
 # Create the ASGI app
-mcp_app = mcp.streamable_http_app(path='/mcp')
+mcp_app = mcp.http_app(path='/mcp')
 
 # Create a FastAPI app and mount the MCP server
 app = FastAPI(lifespan=mcp_app.router.lifespan_context)

fastmcp-2.3.3/docs/deployment/cli.mdx

@@ -0,0 +1,174 @@
+---
+title: FastMCP CLI
+sidebarTitle: CLI
+description: Learn how to use the FastMCP command-line interface
+icon: terminal
+---
+
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
+
+FastMCP provides a command-line interface (CLI) that makes it easy to run, develop, and install your MCP servers. The CLI is automatically installed when you install FastMCP.
+
+```bash
+fastmcp --help
+```
+
+## Commands Overview
+
+| Command | Purpose | Dependency Management |
+| ------- | ------- | --------------------- |
+| `run` | Run a FastMCP server directly | Uses your current environment; you are responsible for ensuring all dependencies are available |
+| `dev` | Run a server with the MCP Inspector for testing | Creates an isolated environment; dependencies must be explicitly specified with `--with` and/or `--with-editable` |
+| `install` | Install a server in the Claude desktop app | Creates an isolated environment; dependencies must be explicitly specified with `--with` and/or `--with-editable` |
+| `version` | Display version information | N/A |
+
+## Command Details
+
+### `run`
+
+Run a FastMCP server directly.
+
+```bash
+fastmcp run server.py
+```
+
+<Tip>
+This command runs the server directly in your current Python environment. You are responsible for ensuring all dependencies are available.
+</Tip>
+
+#### Options
+
+| Option | Flag | Description |
+| ------ | ---- | ----------- |
+| Transport | `--transport`, `-t` | Transport protocol to use (`stdio`, `streamable-http`, or `sse`) |
+| Host | `--host` | Host to bind to when using http transport (default: 127.0.0.1) |
+| Port | `--port`, `-p` | Port to bind to when using http transport (default: 8000) |
+| Log Level | `--log-level`, `-l` | Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL) |
+
+#### Server Specification
+
+The server can be specified in two ways:
+1. `server.py` - imports the module and looks for a FastMCP object named `mcp`, `server`, or `app`. Errors if no such object is found.
+2. `server.py:custom_name` - imports and uses the specified server object
+
+<Tip>
+When using `fastmcp run`, it **ignores** the `if __name__ == "__main__"` block entirely. Instead, it finds your server object and calls its `run()` method directly with the transport options you specify. This means you can use `fastmcp run` to override the transport specified in your code.
+</Tip>
+
+For example, if your code contains:
+
+```python
+# server.py
+from fastmcp import FastMCP
+
+mcp = FastMCP("MyServer")
+
+@mcp.tool()
+def hello(name: str) -> str:
+    return f"Hello, {name}!"
+
+if __name__ == "__main__":
+    # This is ignored when using `fastmcp run`!
+    mcp.run(transport="stdio")
+```
+
+You can run it with Streamable HTTP transport regardless of what's in the `__main__` block:
+
+```bash
+fastmcp run server.py --transport streamable-http --port 8000
+```
+
+**Example**
+
+```bash
+# Run a server with Streamable HTTP transport on a custom port
+fastmcp run server.py --transport streamable-http --port 8000
+```
+
+### `dev`
+
+Run a MCP server with the [MCP Inspector](https://github.com/modelcontextprotocol/inspector) for testing.
+
+```bash
+fastmcp dev server.py
+```
+
+<Tip> 
+This command runs your server in an isolated environment. All dependencies must be explicitly specified using the `--with` and/or `--with-editable` options.
+</Tip>
+
+<Warning>
+The `dev` command is a shortcut for testing a server over STDIO only. When the Inspector launches, you may need to:
+1. Select "STDIO" from the transport dropdown
+2. Connect manually
+
+This command does not support HTTP testing. To test a server over HTTP:
+1. Start your server manually with HTTP transport using either:
+   ```bash
+   fastmcp run server.py --transport streamable-http
+   ```
+   or
+   ```bash
+   python server.py  # Assuming your __main__ block sets HTTP transport
+   ```
+2. Open the MCP Inspector separately and connect to your running server
+</Warning>
+
+#### Options
+
+| Option | Flag | Description |
+| ------ | ---- | ----------- |
+| Editable Package | `--with-editable`, `-e` | Directory containing pyproject.toml to install in editable mode |
+| Additional Packages | `--with` | Additional packages to install (can be used multiple times) |
+| Inspector Version | `--inspector-version` | Version of the MCP Inspector to use |
+| UI Port | `--ui-port` | Port for the MCP Inspector UI |
+| Server Port | `--server-port` | Port for the MCP Inspector Proxy server |
+
+**Example**
+
+```bash
+# Run dev server with editable mode and additional packages
+fastmcp dev server.py -e . --with pandas --with matplotlib
+```
+
+### `install`
+
+Install a MCP server in the Claude desktop app.
+
+```bash
+fastmcp install server.py
+```
+
+<Tip>
+This command installs your server in an isolated environment. All dependencies must be explicitly specified using the `--with` and/or `--with-editable` options.
+</Tip>
+
+<Warning>
+The `install` command currently only sets up servers for STDIO transport. When installed in the Claude desktop app, your server will be run using STDIO regardless of any transport configuration in your code.
+</Warning>
+
+#### Options
+
+| Option | Flag | Description |
+| ------ | ---- | ----------- |
+| Server Name | `--name`, `-n` | Custom name for the server |
+| Editable Package | `--with-editable`, `-e` | Directory containing pyproject.toml to install in editable mode |
+| Additional Packages | `--with` | Additional packages to install (can be used multiple times) |
+| Environment Variables | `--env-var`, `-v` | Environment variables in KEY=VALUE format (can be used multiple times) |
+| Environment File | `--env-file`, `-f` | Load environment variables from a .env file |
+
+**Example**
+
+```bash
+# Install server with custom name, dependencies, and environment variables
+fastmcp install server.py -n "My Analysis Server" -e . --with pandas --env-var API_KEY=12345
+```
+
+### `version`
+
+Display version information about FastMCP and related components.
+
+```bash
+fastmcp version
+```

{fastmcp-2.3.1 → fastmcp-2.3.3}/docs/deployment/running-server.mdx

@@ -11,7 +11,7 @@ FastMCP servers can be run in different ways depending on your application's nee
 
 ## The `run()` Method
 
-The main way to run a FastMCP server from a Python script is by calling the `run()` method on a `FastMCP` instance. 
+FastMCP servers can be run directly from Python by calling the `run()` method on a `FastMCP` instance.
 
 <Tip>
 For maximum compatibility, it's best practice to place the `run()` call within an `if __name__ == "__main__":` block. This ensures the server starts only when the script is executed directly, not when imported as a module.
@@ -33,6 +33,34 @@ You can now run this MCP server by executing `python my_server.py`.
 
 MCP servers can be run with a variety of different transport options, depending on your application's requirements. The `run()` method can take a `transport` argument and other transport-specific keyword arguments to configure how the server operates.
 
+## The FastMCP CLI
+
+FastMCP also provides a command-line interface for running servers without modifying the source code. After installing FastMCP, you can run your server directly from the command line:
+
+```bash
+fastmcp run server.py
+```
+
+<Tip>
+**Important**: When using `fastmcp run`, it **ignores** the `if __name__ == "__main__"` block entirely. Instead, it looks for a FastMCP object named `mcp`, `server`, or `app` and calls its `run()` method directly with the transport options you specify.
+
+This means you can use `fastmcp run` to override the transport specified in your code, which is particularly useful for testing or changing deployment methods without modifying the code.
+</Tip>
+
+You can specify transport options and other configuration:
+
+```bash
+fastmcp run server.py --transport sse --port 9000
+```
+
+For development and testing, you can use the `dev` command to run your server with the MCP Inspector:
+
+```bash
+fastmcp dev server.py
+```
+
+See the [CLI documentation](/deployment/cli) for detailed information about all available commands and options.
+
 ## Transport Options
 
 Below is a comparison of available transport options to help you choose the right one for your needs:
@@ -40,8 +68,8 @@ Below is a comparison of available transport options to help you choose the righ
 | Transport | Use Cases | Recommendation |
 | --------- | --------- | -------------- |
 | **STDIO** | Local tools, command-line scripts, and integrations with clients like Claude Desktop | Best for local tools and when clients manage server processes |
-| **Streamable HTTP** | Web-based deployments, microservices, exposing MCP over a network | Recommended choice for new web-based deployments |
-| **SSE** | Existing web-based deployments that rely on SSE | Suitable for compatibility with SSE clients; prefer Streamable HTTP for new projects |
+| **Streamable HTTP** | Web-based deployments, microservices, exposing MCP over a network | Recommended choice for web-based deployments |
+| **SSE** | Existing web-based deployments that rely on SSE | Deprecated - prefer Streamable HTTP for new projects |
 
 ### STDIO
 
@@ -64,7 +92,7 @@ When using Stdio transport, you will typically *not* run the server yourself as
 
 <VersionBadge version="2.3.0" />
 
-Streamable HTTP is a modern, efficient transport for exposing your MCP server via HTTP. It is generally recommended over SSE for new web-based deployments.
+Streamable HTTP is a modern, efficient transport for exposing your MCP server via HTTP. It is the recommended transport for web-based deployments.
 
 To run a server using Streamable HTTP, you can use the `run()` method with the `transport` argument set to `"streamable-http"`. This will start a Uvicorn server on the default host (`127.0.0.1`), port (`8000`), and path (`/mcp`).
 <CodeGroup>
@@ -122,7 +150,12 @@ if __name__ == "__main__":
 
 ### SSE
 
-Server-Sent Events (SSE) is an HTTP-based protocol for server-to-client streaming. While FastMCP supports SSE, Streamable HTTP is preferred for new projects.
+<Warning>
+The SSE transport is deprecated and may be removed in a future version.
+New applications should use Streamable HTTP transport instead.
+</Warning>
+
+Server-Sent Events (SSE) is an HTTP-based protocol for server-to-client streaming. While FastMCP still supports SSE, it is deprecated and Streamable HTTP is preferred for new projects.
 
 To run a server using SSE, you can use the `run()` method with the `transport` argument set to `"sse"`. This will start a Uvicorn server on the default host (`127.0.0.1`), port (`8000`), and with default SSE path (`/sse`) and message path (`/messages/`).
 
@@ -170,7 +203,6 @@ if __name__ == "__main__":
         port=4200,
         log_level="debug",
         path="/my-custom-sse-path",
-        message_path="/my-custom-message-path/",
     )
 ```
 ```python {7} client.py
@@ -189,9 +221,37 @@ if __name__ == "__main__":
 ```
 </CodeGroup>
 
-Your client only needs to know the host, port, and "main" path; the message path will be transmitted to it as part of the connection handshake.
 
 
+## Async Usage
+
+FastMCP provides both synchronous and asynchronous APIs for running your server. The `run()` method seen in previous examples is a synchronous method that internally uses `anyio.run()` to run the asynchronous server. For applications that are already running in an async context, FastMCP provides the `run_async()` method.
+
+```python {10-12}
+from fastmcp import FastMCP
+import asyncio
+
+mcp = FastMCP(name="MyServer")
+
+@mcp.tool()
+def hello(name: str) -> str:
+    return f"Hello, {name}!"
+
+async def main():
+    # Use run_async() in async contexts
+    await mcp.run_async(transport="streamable-http")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+<Warning>
+The `run()` method cannot be called from inside an async function because it already creates its own async event loop internally. If you attempt to call `run()` from inside an async function, you'll get an error about the event loop already running.
+
+Always use `run_async()` inside async functions and `run()` in synchronous contexts.
+</Warning>
+
+Both `run()` and `run_async()` accept the same transport arguments, so all the examples above apply to both methods.
 
 ## Custom Routes
 

{fastmcp-2.3.1 → fastmcp-2.3.3}/docs/docs.json

@@ -50,8 +50,8 @@
                     "servers/resources",
                     "servers/prompts",
                     "servers/context",
-                    "patterns/proxy",
-                    "patterns/composition"
+                    "servers/proxy",
+                    "servers/composition"
                 ]
             },
             {
@@ -59,7 +59,8 @@
                 "pages": [
                     "deployment/running-server",
                     "deployment/asgi",
-                    "deployment/authentication"
+                    "deployment/authentication",
+                    "deployment/cli"
                 ]
             },
             {
@@ -86,5 +87,15 @@
             }
         ]
     },
+    "redirects": [
+        {
+            "destination": "/servers/proxy",
+            "source": "/patterns/proxy"
+        },
+        {
+            "destination": "/servers/composition",
+            "source": "/patterns/composition"
+        }
+    ],
     "theme": "mint"
 }

{fastmcp-2.3.1 → fastmcp-2.3.3}/docs/getting-started/installation.mdx

@@ -44,7 +44,7 @@ FastMCP root path:            ~/Developer/fastmcp
 ```
 ## Upgrading from the Official MCP SDK
 
-Upgrading from the official MCP SDK's FastMCP 1.0 to FastMCP 2.0 is easy! The core server API is highly compatible, so after you install the `fastmcp` package, just change your import statement from `from mcp.server.fastmcp import FastMCP` to `from fastmcp import FastMCP`. 
+Upgrading from the official MCP SDK's FastMCP 1.0 to FastMCP 2.0 is generally straightforward. The core server API is highly compatible, and in many cases, changing your import statement from `from mcp.server.fastmcp import FastMCP` to `from fastmcp import FastMCP` will be sufficient. 
 
 
 ```python {1-5}
@@ -56,8 +56,9 @@ from fastmcp import FastMCP
 
 mcp = FastMCP("My MCP Server")
 ```
-
-While the 1.0 server API is very stable for common use cases, FastMCP 2.0 introduces many new features (like the Client, proxying, composition) documented throughout this site. Review the documentation for details on new capabilities.
+<Warning>
+Prior to `fastmcp==2.3.0` and `mcp==1.8.0`, the 2.x API always mirrored the 1.0 API. However, as the projects diverge, this can not be guaranteed. You may see deprecation warnings if you attempt to use 1.0 APIs in FastMCP 2.x. Please refer to this documentation for details on new capabilities.
+</Warning>
 
 ## Installing for Development
 

{fastmcp-2.3.1 → fastmcp-2.3.3}/docs/getting-started/welcome.mdx

@@ -27,7 +27,7 @@ if __name__ == "__main__":
 ## FastMCP 2.0 and the Official MCP SDK
 
 <Tip>
-Recognize the `FastMCP` name? You might have used the version integrated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
+Recognize the `FastMCP` name? You might have seen the version that was contributed to the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk), which was based on **FastMCP 1.0**.
 
 
 **Welcome to FastMCP 2.0!** This is the [actively developed successor](https://github.com/jlowin/fastmcp), and it significantly expands on 1.0 by introducing powerful client capabilities, server proxying & composition, OpenAPI/FastAPI integration, and more advanced features.