Merge branch 'main' into protocol-update

.pre-commit-config.yaml

@@ -1,4 +1,4 @@
-fail_fast: true
+fail_fast: false
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject

CLAUDE.md

@@ -27,4 +27,9 @@ Only use HTTP transport when testing network-specific features. Prefer Streamabl
 # Only when network testing is required
 async with Client(transport=StreamableHttpTransport(server_url)) as client:
     result = await client.ping()
-```
+```
+
+## Development Workflow
+
+- You must always run pre-commit if you open a PR, because it is run as part of a required check.
+- When opening PRs, apply labels appropriately for bugs/breaking changes/enhancements/features. Generally, improvements are enhancements (not features) unless told otherwise.

docs/changelog.mdx

@@ -1,5 +1,5 @@
 ---
-mode: center
+icon: "list-check"
 ---
 
 <Update label="v2.8.0" description="2024-06-10">

docs/clients/advanced-features.mdx

@@ -1,152 +0,0 @@
----
-title: Advanced Features
-sidebarTitle: Advanced Features
-description: Learn about the advanced features of the FastMCP Client.
-icon: stars
----
-
-import { VersionBadge } from '/snippets/version-badge.mdx'
-
-In addition to basic server interaction, FastMCP clients can also handle more advanced features and server interaction patterns. The `Client` constructor accepts additional configuration to handle these server requests.
-
-<Tip>
-To enable many of these features, you must provide an appropriate handler or callback function. For example. In most cases, if you do not provide a handler, FastMCP's default handler will emit a `DEBUG` level log.
-</Tip>
-
-## Logging and Notifications
-
-<VersionBadge version="2.0.0" />
-MCP servers can emit logs to clients. To process these logs, you can provide a `log_handler` to the client.
-
-The `log_handler` must be an async function that accepts a single argument, which is an instance of `fastmcp.client.logging.LogMessage`. This has attributes like `level`, `logger`, and `data`.
-
-```python {2, 12}
-from fastmcp import Client
-from fastmcp.client.logging import LogMessage
-
-async def log_handler(message: LogMessage):
-    level = message.level.upper()
-    logger = message.logger or 'default'
-    data = message.data
-    print(f"[Server Log - {level}] {logger}: {data}")
-
-client_with_logging = Client(
-    ...,
-    log_handler=log_handler,
-)
-```
-## Progress Monitoring
-
-<VersionBadge version="2.3.5" />
-
-MCP servers can report progress during long-running operations. The client can set a progress handler to receive and process these updates.
-
-```python {2, 13}
-from fastmcp import Client
-from fastmcp.client.progress import ProgressHandler
-
-async def my_progress_handler(
-    progress: float, 
-    total: float | None, 
-    message: str | None
-) -> None:
-    print(f"Progress: {progress} / {total} ({message})")
-
-client = Client(
-    ...,
-    progress_handler=my_progress_handler
-)
-```
-
-By default, FastMCP uses a handler that logs progress updates at the debug level. This default handler properly handles cases where `total` or `message` might be None.
-
-You can override the progress handler for specific tool calls:
-
-```python
-# Client uses the default debug logger for progress
-client = Client(...)
-
-async with client:
-    # Use default progress handler (debug logging)
-    result1 = await client.call_tool("long_task", {"param": "value"})
-    
-    # Override with custom progress handler just for this call
-    result2 = await client.call_tool(
-        "another_task", 
-        {"param": "value"}, 
-        progress_handler=my_progress_handler
-    )
-```
-
-A typical progress update includes:
-- Current progress value (e.g., 2 of 5 steps completed)
-- Total expected value (may be None)
-- Status message (may be None)
-
-## LLM Sampling
-
-<VersionBadge version="2.0.0" />
-
-MCP Servers can request LLM completions from clients. The client can provide a `sampling_handler` to handle these requests. The sampling handler receives a list of messages and other parameters from the server, and should return a string completion.
-
-The following example uses the `marvin` library to generate a completion:
-
-```python {8-17, 21}
-import marvin
-from fastmcp import Client
-from fastmcp.client.sampling import (
-    SamplingMessage,
-    SamplingParams,
-    RequestContext,
-)
-
-async def sampling_handler(
-    messages: list[SamplingMessage],
-    params: SamplingParams,
-    context: RequestContext
-) -> str:
-    return await marvin.say_async(
-        message=[m.content.text for m in messages],
-        instructions=params.systemPrompt,
-    )
-
-client = Client(
-    ...,
-    sampling_handler=sampling_handler,
-)
-```
-
-
-## Roots
-
-<VersionBadge version="2.0.0" />
-
-Roots are a way for clients to inform servers about the resources they have access to or certain boundaries on their access. The server can use this information to adjust behavior or provide more accurate responses.
-
-Servers can request roots from clients, and clients can notify servers when their roots change.
-
-To set the roots when creating a client, users can either provide a list of roots (which can be a list of strings) or an async function that returns a list of roots.
-
-<CodeGroup>
-```python Static Roots {5}
-from fastmcp import Client
-
-client = Client(
-    ..., 
-    roots=["/path/to/root1", "/path/to/root2"],
-)
-```
-```python Dynamic Roots Callback {4-6, 10}
-from fastmcp import Client
-from fastmcp.client.roots import RequestContext
-
-async def roots_callback(context: RequestContext) -> list[str]:
-    print(f"Server requested roots (Request ID: {context.request_id})")
-    return ["/path/to/root1", "/path/to/root2"]
-
-client = Client(
-    ..., 
-    roots=roots_callback,
-)
-```
-</CodeGroup>

docs/clients/auth/bearer.mdx

@@ -3,7 +3,7 @@ title: Bearer Token Authentication
 sidebarTitle: Bearer Auth
 description: Authenticate your FastMCP client with a Bearer token.
 icon: key
-tag: "New!"
+tag: NEW
 ---
 
 import { VersionBadge } from "/snippets/version-badge.mdx"

docs/clients/auth/oauth.mdx

@@ -3,7 +3,7 @@ title: OAuth Authentication
 sidebarTitle: OAuth
 description: Authenticate your FastMCP client via OAuth 2.1.
 icon: window
-tag: "New!"
+tag: NEW
 ---
 
 import { VersionBadge } from "/snippets/version-badge.mdx"

docs/clients/client.mdx

@@ -1,7 +1,7 @@
 ---
-title: Client Overview
+title: The FastMCP Client
 sidebarTitle: Overview
-description: Learn how to use the FastMCP Client to interact with MCP servers.
+description: Programmatic client for interacting with MCP servers through a well-typed, Pythonic interface.
 icon: user-robot
 ---
 
@@ -9,270 +9,213 @@ import { VersionBadge } from '/snippets/version-badge.mdx'
 
 <VersionBadge version="2.0.0" />
 
-The `fastmcp.Client` provides a high-level, asynchronous interface for interacting with any Model Context Protocol (MCP) server, whether it's built with FastMCP or another implementation. It simplifies communication by handling protocol details and connection management.
+The central piece of MCP client applications is the `fastmcp.Client` class. This class provides a **programmatic interface** for interacting with any Model Context Protocol (MCP) server, handling protocol details and connection management automatically.
 
-## FastMCP Client
+The FastMCP Client is designed for deterministic, controlled interactions rather than autonomous behavior, making it ideal for:
 
-The FastMCP Client architecture separates the protocol logic (`Client`) from the connection mechanism (`Transport`).
+- **Testing MCP servers** during development
+- **Building deterministic applications** that need reliable MCP interactions  
+- **Creating the foundation for agentic or LLM-based clients** with structured, type-safe operations
 
-- **`Client`**: Handles sending MCP requests (like `tools/call`, `resources/read`), receiving responses, and managing callbacks.
-- **`Transport`**: Responsible for establishing and maintaining the connection to the server (e.g., via WebSockets, SSE, Stdio, or in-memory).
+All client operations require using the `async with` context manager for proper connection lifecycle management.
 
-### Transports
 
-Clients must be initialized with a `transport`. You can either provide an already instantiated transport object, or provide a transport source and let FastMCP attempt to infer the correct transport to use.
+<Note>
+This is not an agentic client - it requires explicit function calls and provides direct control over all MCP operations. Use it as a building block for higher-level systems.
+</Note>
 
-The following inference rules are used to determine the appropriate `ClientTransport` based on the input type:
+## Creating a Client
 
-1.  **`ClientTransport` Instance**: If you provide an already instantiated transport object, it's used directly.
-2.  **`FastMCP` Instance**: Creates a `FastMCPTransport` for efficient in-memory communication (ideal for testing). This also works with a **FastMCP 1.0 server** created via `mcp.server.fastmcp.FastMCP`.
-3.  **`Path` or `str` pointing to an existing file**:
-    *   If it ends with `.py`: Creates a `PythonStdioTransport` to run the script using `python`.
-    *   If it ends with `.js`: Creates a `NodeStdioTransport` to run the script using `node`.
-4.  **`AnyUrl` or `str` pointing to a URL that begins with `http://` or `https://`**:
-    *   Creates a `StreamableHttpTransport`
-5.  **`MCPConfig` or dictionary matching MCPConfig schema**: Creates a client that connects to one or more MCP servers specified in the config.
-6.  **Other**: Raises a `ValueError` if the type cannot be inferred.
+Creating a client is straightforward. You provide a server source and the client automatically infers the appropriate transport mechanism.
 
 ```python
 import asyncio
 from fastmcp import Client, FastMCP
 
-# Example transports (more details in Transports page)
-server_instance = FastMCP(name="TestServer") # In-memory server
-http_url = "https://example.com/mcp"        # HTTP server URL
-server_script = "my_mcp_server.py"         # Path to a Python server file
+# In-memory server (ideal for testing)
+server = FastMCP("TestServer")
+client = Client(server)
 
-# Client automatically infers the transport type
-client_in_memory = Client(server_instance)
-client_http = Client(http_url)
+# HTTP server
+client = Client("https://example.com/mcp")
 
-client_stdio = Client(server_script)
+# Local Python script
+client = Client("my_mcp_server.py")
 
-print(client_in_memory.transport)
-print(client_http.transport)
-print(client_stdio.transport)
+async def main():
+    async with client:
+        # Basic server interaction
+        await client.ping()
+        
+        # List available operations
+        tools = await client.list_tools()
+        resources = await client.list_resources()
+        prompts = await client.list_prompts()
+        
+        # Execute operations
+        result = await client.call_tool("example_tool", {"param": "value"})
+        print(result)
 
-# Expected Output (types may vary slightly based on environment):
-# <FastMCP(server='TestServer')>
-# <StreamableHttp(url='https://example.com/mcp')>
-# <PythonStdioTransport(command='python', args=['/path/to/your/my_mcp_server.py'])>
+asyncio.run(main())
 ```
 
-You can also initialize a client from an MCP configuration dictionary or `MCPConfig` file:
+## Client-Transport Architecture
 
-```python
-from fastmcp import Client
+The FastMCP Client separates concerns between protocol and connection:
 
-config = {
-    "mcpServers": {
-        "local": {"command": "python", "args": ["local_server.py"]},
-        "remote": {"url": "https://example.com/mcp"},
-    }
-}
+- **`Client`**: Handles MCP protocol operations (tools, resources, prompts) and manages callbacks
+- **`Transport`**: Establishes and maintains the connection (WebSockets, HTTP, Stdio, in-memory)
+
+### Transport Inference
+
+The client automatically infers the appropriate transport based on the input:
+
+1. **`FastMCP` instance** → In-memory transport (perfect for testing)
+2. **File path ending in `.py`** → Python Stdio transport
+3. **File path ending in `.js`** → Node.js Stdio transport  
+4. **URL starting with `http://` or `https://`** → HTTP transport
+5. **`MCPConfig` dictionary** → Multi-server client
+
+```python
+from fastmcp import Client, FastMCP
 
-client_config = Client(config)
+# Examples of transport inference
+client_memory = Client(FastMCP("TestServer"))
+client_script = Client("./server.py") 
+client_http = Client("https://api.example.com/mcp")
 ```
+
 <Tip>
-For more control over connection details (like headers for SSE, environment variables for Stdio), you can instantiate the specific `ClientTransport` class yourself and pass it to the `Client`. See the [Transports](/clients/transports) page for details.
+For testing and development, always prefer the in-memory transport by passing a `FastMCP` server directly to the client. This eliminates network complexity and separate processes.
 </Tip>
 
-### Multi-Server Clients
+## Configuration-Based Clients
 
 <VersionBadge version="2.4.0" />
 
-FastMCP supports creating clients that connect to multiple MCP servers through a single client interface using a standard MCP configuration format (`MCPConfig`). This configuration approach makes it easy to connect to multiple specialized servers or create composable systems with a simple, declarative syntax.
-
-<Note>
-The MCP configuration format follows an emerging standard and may evolve as the specification matures. FastMCP will strive to maintain compatibility with future versions, but be aware that field names or structure might change.
-</Note>
-
-When you create a client with an `MCPConfig` containing multiple servers:
+Create clients from MCP configuration dictionaries, which can include multiple servers. While there is no official standard for MCP configuration format, FastMCP follows established conventions used by tools like Claude Desktop.
 
-1. FastMCP creates a composite client that internally mounts all servers using their config names as prefixes
-2. Tools and resources from each server are accessible with appropriate prefixes in the format `servername_toolname` and `protocol://servername/resource/path`
-3. You interact with this as a single unified client, with requests automatically routed to the appropriate server
+### Configuration Format
 
 ```python
-from fastmcp import Client
-
-# Create a standard MCP configuration with multiple servers
 config = {
     "mcpServers": {
-        # A remote HTTP server
-        "weather": {
-            "url": "https://weather-api.example.com/mcp",
-            "transport": "streamable-http"
+        "server_name": {
+            # Remote HTTP/SSE server
+            "transport": "streamable-http",  # or "sse" 
+            "url": "https://api.example.com/mcp",
+            "headers": {"Authorization": "Bearer token"},
+            "auth": "oauth"  # or bearer token string
         },
-        # A local server running via stdio
-        "assistant": {
+        "local_server": {
+            # Local stdio server
+            "transport": "stdio"
             "command": "python",
-            "args": ["./my_assistant_server.py"],
-            "env": {"DEBUG": "true"}
+            "args": ["./server.py", "--verbose"],
+            "env": {"DEBUG": "true"},
+            "cwd": "/path/to/server",
         }
     }
 }
-
-# Create a client that connects to both servers
-client = Client(config)
-
-async def main():
-    async with client:
-        # Access tools from different servers with prefixes
-        weather_data = await client.call_tool("weather_get_forecast", {"city": "London"})
-        response = await client.call_tool("assistant_answer_question", {"question": "What's the capital of France?"})
-        
-        # Access resources with prefixed URIs
-        weather_icons = await client.read_resource("weather://weather/icons/sunny")
-        templates = await client.read_resource("resource://assistant/templates/list")
-        
-        print(f"Weather: {weather_data}")
-        print(f"Assistant: {response}")
-
-if __name__ == "__main__":
-    asyncio.run(main())
 ```
 
-If your configuration has only a single server, FastMCP will create a direct client to that server without any prefixing.
+### Multi-Server Example
 
-## Client Usage
+```python
+config = {
+    "mcpServers": {
+        "weather": {"url": "https://weather-api.example.com/mcp"},
+        "assistant": {"command": "python", "args": ["./assistant_server.py"]}
+    }
+}
 
-### Connection Lifecycle
+client = Client(config)
 
-The client operates asynchronously and must be used within an `async with` block. This context manager handles establishing the connection, initializing the MCP session, and cleaning up resources upon exit.
+async with client:
+    # Tools are prefixed with server names
+    weather_data = await client.call_tool("weather_get_forecast", {"city": "London"})
+    response = await client.call_tool("assistant_answer_question", {"question": "What's the capital of France?"})
+    
+    # Resources use prefixed URIs
+    icons = await client.read_resource("weather://weather/icons/sunny")
+    templates = await client.read_resource("resource://assistant/templates/list")
+```
 
-```python
-import asyncio
-from fastmcp import Client
+## Connection Lifecycle
 
-client = Client("my_mcp_server.py") # Assumes my_mcp_server.py exists
+The client operates asynchronously and uses context managers for connection management:
 
-async def main():
-    # Connection is established here
+```python
+async def example():
+    client = Client("my_mcp_server.py")
+    
+    # Connection established here
     async with client:
-        print(f"Client connected: {client.is_connected()}")
-
-        # Make MCP calls within the context
+        print(f"Connected: {client.is_connected()}")
+        
+        # Make multiple calls within the same session
         tools = await client.list_tools()
-        print(f"Available tools: {tools}")
-
-        if any(tool.name == "greet" for tool in tools):
-            result = await client.call_tool("greet", {"name": "World"})
-            print(f"Greet result: {result}")
-
-    # Connection is closed automatically here
-    print(f"Client connected: {client.is_connected()}")
-
-if __name__ == "__main__":
-    asyncio.run(main())
+        result = await client.call_tool("greet", {"name": "World"})
+        
+    # Connection closed automatically here
+    print(f"Connected: {client.is_connected()}")
 ```
 
-You can make multiple calls to the server within the same `async with` block using the established session.
-
-### Client Methods
+## Operations
 
-The `Client` provides methods corresponding to standard MCP requests:
+FastMCP clients can interact with several types of server components:
 
-<Warning>
-The standard client methods return user-friendly representations that may change as the protocol evolves. For consistent access to the complete data structure, use the `*_mcp` methods described later.
-</Warning>
+### Tools
 
-#### Tool Operations
+Tools are server-side functions that the client can execute with arguments.
 
-*   **`list_tools()`**: Retrieves a list of tools available on the server.
-    ```python
+```python
+async with client:
+    # List available tools
     tools = await client.list_tools()
-    # tools -> list[mcp.types.Tool]
-    ```
-*   **`call_tool(name: str, arguments: dict[str, Any] | None = None, timeout: float | None = None, progress_handler: ProgressHandler | None = None)`**: Executes a tool on the server.
-    ```python
-    result = await client.call_tool("add", {"a": 5, "b": 3})
-    # result -> list[mcp.types.TextContent | mcp.types.ImageContent | ...]
-    print(result[0].text) # Assuming TextContent, e.g., '8'
-    
-    # With timeout (aborts if execution takes longer than 2 seconds)
-    result = await client.call_tool("long_running_task", {"param": "value"}, timeout=2.0)
     
-    # With progress handler (to track execution progress)
-    result = await client.call_tool(
-        "long_running_task",
-        {"param": "value"},
-        progress_handler=my_progress_handler
-    )
-    ```
-    *   Arguments are passed as a dictionary. FastMCP servers automatically handle JSON string parsing for complex types if needed.
-    *   Returns a list of content objects (usually `TextContent` or `ImageContent`).
-    *   The optional `timeout` parameter limits the maximum execution time (in seconds) for this specific call, overriding any client-level timeout.
-    *   The optional `progress_handler` parameter receives progress updates during execution, overriding any client-level progress handler.
-
-#### Resource Operations
-
-*   **`list_resources()`**: Retrieves a list of static resources.
-    ```python
-    resources = await client.list_resources()
-    # resources -> list[mcp.types.Resource]
-    ```
-*   **`list_resource_templates()`**: Retrieves a list of resource templates.
-    ```python
-    templates = await client.list_resource_templates()
-    # templates -> list[mcp.types.ResourceTemplate]
-    ```
-*   **`read_resource(uri: str | AnyUrl)`**: Reads the content of a resource or a resolved template.
-    ```python
-    # Read a static resource
-    readme_content = await client.read_resource("file:///path/to/README.md")
-    # readme_content -> list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]
-    print(readme_content[0].text) # Assuming text
+    # Execute a tool
+    result = await client.call_tool("multiply", {"a": 5, "b": 3})
+    print(result[0].text)  # "15"
+```
 
-    # Read a resource generated from a template
-    weather_content = await client.read_resource("data://weather/london")
-    print(weather_content[0].text) # Assuming text JSON
-    ```
+See [Tools](/clients/tools) for detailed documentation.
 
-#### Prompt Operations
+### Resources
 
-*   **`list_prompts()`**: Retrieves available prompt templates.
-*   **`get_prompt(name: str, arguments: dict[str, Any] | None = None)`**: Retrieves a rendered prompt message list.
+Resources are data sources that the client can read, either static or templated.
 
-### Raw MCP Protocol Objects
+```python
+async with client:
+    # List available resources
+    resources = await client.list_resources()
+    
+    # Read a resource
+    content = await client.read_resource("file:///config/settings.json")
+    print(content[0].text)
+```
 
-<VersionBadge version="2.2.7" />
+See [Resources](/clients/resources) for detailed documentation.
 
-The FastMCP client attempts to provide a "friendly" interface to the MCP protocol, but sometimes you may need access to the raw MCP protocol objects. Each of the main client methods that returns data has a corresponding `*_mcp` method that returns the raw MCP protocol objects directly.
+### Prompts
 
-<Warning>
-The standard client methods (without `_mcp`) return user-friendly representations of MCP data, while `*_mcp` methods will always return the complete MCP protocol objects. As the protocol evolves, changes to these user-friendly representations may occur and could potentially be breaking. If you need consistent, stable access to the full data structure, prefer using the `*_mcp` methods.
-</Warning>
+Prompts are reusable message templates that can accept arguments.
 
 ```python
-# Standard method - returns just the list of tools
-tools = await client.list_tools()
-# tools -> list[mcp.types.Tool]
-
-# Raw MCP method - returns the full protocol object
-result = await client.list_tools_mcp()
-# result -> mcp.types.ListToolsResult
-tools = result.tools
+async with client:
+    # List available prompts
+    prompts = await client.list_prompts()
+    
+    # Get a rendered prompt
+    messages = await client.get_prompt("analyze_data", {"data": [1, 2, 3]})
+    print(messages.messages)
 ```
 
-Available raw MCP methods:
-
-*   **`list_tools_mcp()`**: Returns `mcp.types.ListToolsResult`
-*   **`call_tool_mcp(name, arguments)`**: Returns `mcp.types.CallToolResult`
-*   **`list_resources_mcp()`**: Returns `mcp.types.ListResourcesResult`
-*   **`list_resource_templates_mcp()`**: Returns `mcp.types.ListResourceTemplatesResult`
-*   **`read_resource_mcp(uri)`**: Returns `mcp.types.ReadResourceResult`
-*   **`list_prompts_mcp()`**: Returns `mcp.types.ListPromptsResult`
-*   **`get_prompt_mcp(name, arguments)`**: Returns `mcp.types.GetPromptResult`
-*   **`complete_mcp(ref, argument)`**: Returns `mcp.types.CompleteResult`
+See [Prompts](/clients/prompts) for detailed documentation.
 
-These methods are especially useful for debugging or when you need to access metadata or fields that aren't exposed by the simplified methods.
+### Server Connectivity
 
-### Additional Features
-
-#### Pinging the Server
-
-The client can be used to ping the server to verify connectivity.
+Use `ping()` to verify the server is reachable:
 
 ```python
 async with client:
@@ -280,93 +223,69 @@ async with client:
     print("Server is reachable")
 ```
 
-#### Session Management
+## Client Configuration
+
+Clients can be configured with additional handlers and settings for specialized use cases.
 
-When using stdio transports, clients support a `keep_alive` feature (enabled by default) that maintains subprocess sessions between connection contexts. You can manually control this behavior using the client's `close()` method.
+### Callback Handlers
 
-When `keep_alive=False`, the client will automatically close the session when the context manager exits.
+The client supports several callback handlers for advanced server interactions:
 
 ```python
 from fastmcp import Client
+from fastmcp.client.logging import LogMessage
 
-client = Client("my_mcp_server.py")  # keep_alive=True by default
+async def log_handler(message: LogMessage):
+    print(f"Server log: {message.data}")
 
-async def example():
-    async with client:
-        await client.ping()
-    
-    async with client:
-        await client.ping()  # Same subprocess as above
-```
-
-<Note>
-For detailed examples and configuration options, see [Session Management in Transports](/clients/transports#session-management).
-</Note>
-
-#### Timeouts
-
-<VersionBadge version="2.3.4" />
-
-You can control request timeouts at both the client level and individual request level:
+async def progress_handler(progress: float, total: float | None, message: str | None):
+    print(f"Progress: {progress}/{total} - {message}")
 
-```python
-from fastmcp import Client
-from fastmcp.exceptions import McpError
+async def sampling_handler(messages, params, context):
+    # Integrate with your LLM service here
+    return "Generated response"
 
-# Client with a global 5-second timeout for all requests
 client = Client(
-    my_mcp_server,
-    timeout=5.0  # Default timeout in seconds
+    "my_mcp_server.py",
+    log_handler=log_handler,
+    progress_handler=progress_handler,
+    sampling_handler=sampling_handler,
+    timeout=30.0
 )
-
-async with client:
-    # This uses the global 5-second timeout
-    result1 = await client.call_tool("quick_task", {"param": "value"})
-    
-    # This specifies a 10-second timeout for this specific call
-    result2 = await client.call_tool("slow_task", {"param": "value"}, timeout=10.0)
-    
-    try:
-        # This will likely timeout
-        result3 = await client.call_tool("medium_task", {"param": "value"}, timeout=0.01)
-    except McpError as e:
-        # Handle timeout error
-        print(f"The task timed out: {e}")
 ```
 
-<Warning>
-Timeout behavior varies between transport types:
+The `Client` constructor accepts several configuration options:
 
-- With **SSE** transport, the per-request (tool call) timeout **always** takes precedence, regardless of which is lower.
-- With **HTTP** transport, the **lower** of the two timeouts (client or tool call) takes precedence.
+- `transport`: Transport instance or source for automatic inference  
+- `log_handler`: Handle server log messages
+- `progress_handler`: Monitor long-running operations
+- `sampling_handler`: Respond to server LLM requests
+- `roots`: Provide local context to servers
+- `timeout`: Default timeout for requests (in seconds)
 
-For consistent behavior across all transports, we recommend explicitly setting timeouts at the individual tool call level when needed, rather than relying on client-level timeouts.
-</Warning>
+### Transport Configuration
 
-#### Error Handling
+For detailed transport configuration (headers, authentication, environment variables), see the [Transports](/clients/transports) documentation.
 
-When a `call_tool` request results in an error on the server (e.g., the tool function raised an exception), the `client.call_tool()` method will raise a `fastmcp.exceptions.ClientError`.
+## Next Steps
 
-```python
-async def safe_call_tool():
-    async with client:
-        try:
-            # Assume 'divide' tool exists and might raise ZeroDivisionError
-            result = await client.call_tool("divide", {"a": 10, "b": 0})
-            print(f"Result: {result}")
-        except ClientError as e:
-            print(f"Tool call failed: {e}")
-        except ConnectionError as e:
-            print(f"Connection failed: {e}")
-        except Exception as e:
-            print(f"An unexpected error occurred: {e}")
-
-# Example Output if division by zero occurs:
-# Tool call failed: Division by zero is not allowed.
-```
+Explore the detailed documentation for each operation type:
 
-Other errors, like connection failures, will raise standard Python exceptions (e.g., `ConnectionError`, `TimeoutError`). 
+### Core Operations
+- **[Tools](/clients/tools)** - Execute server-side functions and handle results
+- **[Resources](/clients/resources)** - Access static and templated resources  
+- **[Prompts](/clients/prompts)** - Work with message templates and argument serialization
+
+### Advanced Features
+- **[Logging](/clients/logging)** - Handle server log messages
+- **[Progress](/clients/progress)** - Monitor long-running operations
+- **[Sampling](/clients/sampling)** - Respond to server LLM requests
+- **[Roots](/clients/roots)** - Provide local context to servers
+
+### Connection Details
+- **[Transports](/clients/transports)** - Configure connection methods and parameters
+- **[Authentication](/clients/auth/oauth)** - Set up OAuth and bearer token authentication
 
 <Tip>
-The client transport often has its own error-handling mechanisms, so you can not always trap errors like those raised by `call_tool` outside of the `async with` block. Instead, you can use `call_tool_mcp()` to get the raw `mcp.types.CallToolResult` object and handle errors yourself by checking its `isError` attribute.
-</Tip>
+The FastMCP Client is designed as a foundational tool. Use it directly for deterministic operations, or build higher-level agentic systems on top of its reliable, type-safe interface.
+</Tip>

docs/clients/logging.mdx

@@ -0,0 +1,63 @@
+---
+title: Server Logging
+sidebarTitle: Logging
+description: Receive and handle log messages from MCP servers.
+icon: receipt
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+MCP servers can emit log messages to clients. The client can handle these logs through a log handler callback.
+
+## Setting Up Log Handling
+
+Provide a `log_handler` function when creating the client:
+
+```python
+from fastmcp import Client
+from fastmcp.client.logging import LogMessage
+
+async def log_handler(message: LogMessage):
+    level = message.level.upper()
+    logger = message.logger or 'server'
+    data = message.data
+    print(f"[{level}] {logger}: {data}")
+
+client = Client(
+    "my_mcp_server.py",
+    log_handler=log_handler,
+)
+```
+
+## LogMessage Structure
+
+The `log_handler` receives a `LogMessage` object with:
+
+- **`level`**: Log level (e.g., "debug", "info", "warning", "error")
+- **`logger`**: Logger name (optional, may be None)
+- **`data`**: The actual log message content
+
+```python
+async def detailed_log_handler(message: LogMessage):
+    if message.level == "error":
+        print(f"ERROR: {message.data}")
+    elif message.level == "warning":
+        print(f"WARNING: {message.data}")
+    else:
+        print(f"{message.level.upper()}: {message.data}")
+```
+
+## Default Log Handling
+
+If you don't provide a custom `log_handler`, FastMCP uses a default handler that emits DEBUG level logs:
+
+```python
+# Without custom handler - uses default DEBUG logging
+client = Client("my_mcp_server.py")
+
+async with client:
+    # Server logs will be emitted at DEBUG level
+    await client.call_tool("some_tool")
+```

docs/clients/progress.mdx

@@ -0,0 +1,59 @@
+---
+title: Progress Monitoring
+sidebarTitle: Progress
+description: Handle progress notifications from long-running server operations.
+icon: bars-progress
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.3.5" />
+
+MCP servers can report progress during long-running operations. The client can receive these updates through a progress handler.
+
+## Setting Up Progress Handling
+
+Set a progress handler when creating the client:
+
+```python
+from fastmcp import Client
+
+async def my_progress_handler(
+    progress: float, 
+    total: float | None, 
+    message: str | None
+) -> None:
+    if total is not None:
+        percentage = (progress / total) * 100
+        print(f"Progress: {percentage:.1f}% - {message or ''}")
+    else:
+        print(f"Progress: {progress} - {message or ''}")
+
+client = Client(
+    "my_mcp_server.py",
+    progress_handler=my_progress_handler
+)
+```
+
+## Per-Call Progress Handler
+
+Override the progress handler for specific tool calls:
+
+```python
+async with client:
+    # Override with specific progress handler for this call
+    result = await client.call_tool(
+        "long_running_task", 
+        {"param": "value"}, 
+        progress_handler=my_progress_handler
+    )
+```
+
+## Handler Parameters
+
+The progress handler receives:
+
+- **`progress`** (float): Current progress value
+- **`total`** (float | None): Expected total value (may be None)
+- **`message`** (str | None): Optional status message (may be None)
+

docs/clients/prompts.mdx

@@ -0,0 +1,187 @@
+---
+title: Prompts
+sidebarTitle: Prompts
+description: Use server-side prompt templates with automatic argument serialization.
+icon: message-lines
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+Prompts are reusable message templates exposed by MCP servers. They can accept arguments to generate personalized message sequences for LLM interactions.
+
+## Listing Prompts
+
+Use `list_prompts()` to retrieve all available prompt templates:
+
+```python
+async with client:
+    prompts = await client.list_prompts()
+    # prompts -> list[mcp.types.Prompt]
+    
+    for prompt in prompts:
+        print(f"Prompt: {prompt.name}")
+        print(f"Description: {prompt.description}")
+        if prompt.arguments:
+            print(f"Arguments: {[arg.name for arg in prompt.arguments]}")
+```
+
+## Using Prompts
+
+### Basic Usage
+
+Request a rendered prompt using `get_prompt()` with the prompt name and arguments:
+
+```python
+async with client:
+    # Simple prompt without arguments
+    result = await client.get_prompt("welcome_message")
+    # result -> mcp.types.GetPromptResult
+    
+    # Access the generated messages
+    for message in result.messages:
+        print(f"Role: {message.role}")
+        print(f"Content: {message.content}")
+```
+
+### Prompts with Arguments
+
+Pass arguments as a dictionary to customize the prompt:
+
+```python
+async with client:
+    # Prompt with simple arguments
+    result = await client.get_prompt("user_greeting", {
+        "name": "Alice",
+        "role": "administrator"
+    })
+    
+    # Access the personalized messages
+    for message in result.messages:
+        print(f"Generated message: {message.content}")
+```
+
+## Automatic Argument Serialization
+
+<VersionBadge version="2.9.0" />
+
+FastMCP automatically serializes complex arguments to JSON strings as required by the MCP specification. This allows you to pass typed objects directly:
+
+```python
+from dataclasses import dataclass
+
+@dataclass
+class UserData:
+    name: str
+    age: int
+
+async with client:
+    # Complex arguments are automatically serialized
+    result = await client.get_prompt("analyze_user", {
+        "user": UserData(name="Alice", age=30),     # Automatically serialized to JSON
+        "preferences": {"theme": "dark"},           # Dict serialized to JSON string
+        "scores": [85, 92, 78],                     # List serialized to JSON string
+        "simple_name": "Bob"                        # Strings passed through unchanged
+    })
+```
+
+The client handles serialization using `pydantic_core.to_json()` for consistent formatting. FastMCP servers can automatically deserialize these JSON strings back to the expected types.
+
+### Serialization Examples
+
+```python
+async with client:
+    result = await client.get_prompt("data_analysis", {
+        # These will be automatically serialized to JSON strings:
+        "config": {
+            "format": "csv",
+            "include_headers": True,
+            "delimiter": ","
+        },
+        "filters": [
+            {"field": "age", "operator": ">", "value": 18},
+            {"field": "status", "operator": "==", "value": "active"}
+        ],
+        # This remains a string:
+        "report_title": "Monthly Analytics Report"
+    })
+```
+
+## Working with Prompt Results
+
+The `get_prompt()` method returns a `GetPromptResult` object containing a list of messages:
+
+```python
+async with client:
+    result = await client.get_prompt("conversation_starter", {"topic": "climate"})
+    
+    # Access individual messages
+    for i, message in enumerate(result.messages):
+        print(f"Message {i + 1}:")
+        print(f"  Role: {message.role}")
+        print(f"  Content: {message.content.text if hasattr(message.content, 'text') else message.content}")
+```
+
+## Raw MCP Protocol Access
+
+For access to the complete MCP protocol objects, use the `*_mcp` methods:
+
+```python
+async with client:
+    # Raw MCP method returns full protocol object
+    prompts_result = await client.list_prompts_mcp()
+    # prompts_result -> mcp.types.ListPromptsResult
+    
+    prompt_result = await client.get_prompt_mcp("example_prompt", {"arg": "value"})
+    # prompt_result -> mcp.types.GetPromptResult
+```
+
+## Multi-Server Clients
+
+When using multi-server clients, prompts are accessible without prefixing (unlike tools):
+
+```python
+async with client:  # Multi-server client
+    # Prompts from any server are directly accessible
+    result1 = await client.get_prompt("weather_prompt", {"city": "London"})
+    result2 = await client.get_prompt("assistant_prompt", {"query": "help"})
+```
+
+## Common Prompt Patterns
+
+### System Messages
+
+Many prompts generate system messages for LLM configuration:
+
+```python
+async with client:
+    result = await client.get_prompt("system_configuration", {
+        "role": "helpful assistant",
+        "expertise": "python programming"
+    })
+    
+    # Typically returns messages with role="system"
+    system_message = result.messages[0]
+    print(f"System prompt: {system_message.content}")
+```
+
+### Conversation Templates
+
+Prompts can generate multi-turn conversation templates:
+
+```python
+async with client:
+    result = await client.get_prompt("interview_template", {
+        "candidate_name": "Alice",
+        "position": "Senior Developer"
+    })
+    
+    # Multiple messages for a conversation flow
+    for message in result.messages:
+        print(f"{message.role}: {message.content}")
+```
+
+<Tip>
+Prompt arguments and their expected types depend on the specific prompt implementation. Check the server's documentation or use `list_prompts()` to see available arguments for each prompt.
+</Tip>

docs/clients/resources.mdx

@@ -0,0 +1,171 @@
+---
+title: Resource Operations
+sidebarTitle: Resources
+description: Access static and templated resources from MCP servers.
+icon: folder-open
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+Resources are data sources exposed by MCP servers. They can be static files or dynamic templates that generate content based on parameters.
+
+## Types of Resources
+
+MCP servers expose two types of resources:
+
+- **Static Resources**: Fixed content accessible via URI (e.g., configuration files, documentation)
+- **Resource Templates**: Dynamic resources that accept parameters to generate content (e.g., API endpoints, database queries)
+
+## Listing Resources
+
+### Static Resources
+
+Use `list_resources()` to retrieve all static resources available on the server:
+
+```python
+async with client:
+    resources = await client.list_resources()
+    # resources -> list[mcp.types.Resource]
+    
+    for resource in resources:
+        print(f"Resource URI: {resource.uri}")
+        print(f"Name: {resource.name}")
+        print(f"Description: {resource.description}")
+        print(f"MIME Type: {resource.mimeType}")
+```
+
+### Resource Templates
+
+Use `list_resource_templates()` to retrieve available resource templates:
+
+```python
+async with client:
+    templates = await client.list_resource_templates()
+    # templates -> list[mcp.types.ResourceTemplate]
+    
+    for template in templates:
+        print(f"Template URI: {template.uriTemplate}")
+        print(f"Name: {template.name}")
+        print(f"Description: {template.description}")
+```
+
+## Reading Resources
+
+### Static Resources
+
+Read a static resource using its URI:
+
+```python
+async with client:
+    # Read a static resource
+    content = await client.read_resource("file:///path/to/README.md")
+    # content -> list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]
+    
+    # Access text content
+    if hasattr(content[0], 'text'):
+        print(content[0].text)
+    
+    # Access binary content
+    if hasattr(content[0], 'blob'):
+        print(f"Binary data: {len(content[0].blob)} bytes")
+```
+
+### Resource Templates
+
+Read from a resource template by providing the URI with parameters:
+
+```python
+async with client:
+    # Read a resource generated from a template
+    # For example, a template like "weather://{{city}}/current"
+    weather_content = await client.read_resource("weather://london/current")
+    
+    # Access the generated content
+    print(weather_content[0].text)  # Assuming text JSON response
+```
+
+## Content Types
+
+Resources can return different content types:
+
+### Text Resources
+
+```python
+async with client:
+    content = await client.read_resource("resource://config/settings.json")
+    
+    for item in content:
+        if hasattr(item, 'text'):
+            print(f"Text content: {item.text}")
+            print(f"MIME type: {item.mimeType}")
+```
+
+### Binary Resources
+
+```python
+async with client:
+    content = await client.read_resource("resource://images/logo.png")
+    
+    for item in content:
+        if hasattr(item, 'blob'):
+            print(f"Binary content: {len(item.blob)} bytes")
+            print(f"MIME type: {item.mimeType}")
+            
+            # Save to file
+            with open("downloaded_logo.png", "wb") as f:
+                f.write(item.blob)
+```
+
+## Working with Multi-Server Clients
+
+When using multi-server clients, resource URIs are automatically prefixed with the server name:
+
+```python
+async with client:  # Multi-server client
+    # Access resources from different servers
+    weather_icons = await client.read_resource("weather://weather/icons/sunny")
+    templates = await client.read_resource("resource://assistant/templates/list")
+    
+    print(f"Weather icon: {weather_icons[0].blob}")
+    print(f"Templates: {templates[0].text}")
+```
+
+## Raw MCP Protocol Access
+
+For access to the complete MCP protocol objects, use the `*_mcp` methods:
+
+```python
+async with client:
+    # Raw MCP methods return full protocol objects
+    resources_result = await client.list_resources_mcp()
+    # resources_result -> mcp.types.ListResourcesResult
+    
+    templates_result = await client.list_resource_templates_mcp()
+    # templates_result -> mcp.types.ListResourceTemplatesResult
+    
+    content_result = await client.read_resource_mcp("resource://example")
+    # content_result -> mcp.types.ReadResourceResult
+```
+
+## Common Resource URI Patterns
+
+Different MCP servers may use various URI schemes:
+
+```python
+# File system resources
+"file:///path/to/file.txt"
+
+# Custom protocol resources  
+"weather://london/current"
+"database://users/123"
+
+# Generic resource protocol
+"resource://config/settings"
+"resource://templates/email"
+```
+
+<Tip>
+Resource URIs and their formats depend on the specific MCP server implementation. Check the server's documentation for available resources and their URI patterns.
+</Tip>

docs/clients/roots.mdx

@@ -0,0 +1,42 @@
+---
+title: Client Roots
+sidebarTitle: Roots
+description: Provide local context and resource boundaries to MCP servers.
+icon: folder-tree
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+Roots are a way for clients to inform servers about the resources they have access to. Servers can use this information to adjust behavior or provide more relevant responses.
+
+## Setting Static Roots
+
+Provide a list of roots when creating the client:
+
+<CodeGroup>
+```python Static Roots
+from fastmcp import Client
+
+client = Client(
+    "my_mcp_server.py", 
+    roots=["/path/to/root1", "/path/to/root2"]
+)
+```
+
+```python Dynamic Roots Callback
+from fastmcp import Client
+from fastmcp.client.roots import RequestContext
+
+async def roots_callback(context: RequestContext) -> list[str]:
+    print(f"Server requested roots (Request ID: {context.request_id})")
+    return ["/path/to/root1", "/path/to/root2"]
+
+client = Client(
+    "my_mcp_server.py", 
+    roots=roots_callback
+)
+```
+</CodeGroup>
+

docs/clients/sampling.mdx

@@ -0,0 +1,91 @@
+---
+title: LLM Sampling
+sidebarTitle: Sampling
+description: Handle server-initiated LLM sampling requests.
+icon: robot
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+MCP servers can request LLM completions from clients. The client handles these requests through a sampling handler callback.
+
+## Setting Up Sampling Handling
+
+Provide a `sampling_handler` function when creating the client:
+
+```python
+from fastmcp import Client
+from fastmcp.client.sampling import (
+    SamplingMessage,
+    SamplingParams,
+    RequestContext,
+)
+
+async def sampling_handler(
+    messages: list[SamplingMessage],
+    params: SamplingParams,
+    context: RequestContext
+) -> str:
+    # Your LLM integration logic here
+    # Extract text from messages and generate a response
+    return "Generated response based on the messages"
+
+client = Client(
+    "my_mcp_server.py",
+    sampling_handler=sampling_handler,
+)
+```
+
+## Handler Parameters
+
+The sampling handler receives three parameters:
+
+### SamplingMessage
+
+- **`role`**: Message role (e.g., "user", "assistant", "system")
+- **`content`**: Message content (usually has `.text` attribute)
+
+### SamplingParams
+
+- **`systemPrompt`**: System prompt string (optional)
+- **`maxTokens`**: Maximum tokens to generate (optional)
+- **`temperature`**: Sampling temperature (optional)
+- **`topP`**: Top-p sampling parameter (optional)
+- **`stopSequences`**: List of stop sequences (optional)
+
+### RequestContext
+
+- **`request_id`**: Unique identifier for the sampling request
+
+## Basic Example
+
+```python
+from fastmcp import Client
+from fastmcp.client.sampling import SamplingMessage, SamplingParams, RequestContext
+
+async def basic_sampling_handler(
+    messages: list[SamplingMessage],
+    params: SamplingParams,
+    context: RequestContext
+) -> str:
+    # Extract message content
+    conversation = []
+    for message in messages:
+        content = message.content.text if hasattr(message.content, 'text') else str(message.content)
+        conversation.append(f"{message.role}: {content}")
+    
+    # Use the system prompt if provided
+    system_prompt = params.systemPrompt or "You are a helpful assistant."
+    
+    # Here you would integrate with your preferred LLM service
+    # This is just a placeholder response
+    return f"Response based on conversation: {' | '.join(conversation)}"
+
+client = Client(
+    "my_mcp_server.py",
+    sampling_handler=basic_sampling_handler
+)
+```
+

docs/clients/tools.mdx

@@ -0,0 +1,143 @@
+---
+title: Tool Operations
+sidebarTitle: Tools
+description: Discover and execute server-side tools with the FastMCP client.
+icon: wrench
+---
+
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+Tools are executable functions exposed by MCP servers. The FastMCP client provides methods to discover available tools and execute them with arguments.
+
+## Discovering Tools
+
+Use `list_tools()` to retrieve all tools available on the server:
+
+```python
+async with client:
+    tools = await client.list_tools()
+    # tools -> list[mcp.types.Tool]
+    
+    for tool in tools:
+        print(f"Tool: {tool.name}")
+        print(f"Description: {tool.description}")
+        if tool.inputSchema:
+            print(f"Parameters: {tool.inputSchema}")
+```
+
+## Executing Tools
+
+### Basic Execution
+
+Execute a tool using `call_tool()` with the tool name and arguments:
+
+```python
+async with client:
+    # Simple tool call
+    result = await client.call_tool("add", {"a": 5, "b": 3})
+    # result -> list[mcp.types.TextContent | mcp.types.ImageContent | ...]
+    
+    # Access the result content
+    print(result[0].text)  # Assuming TextContent, e.g., '8'
+```
+
+### Advanced Execution Options
+
+The `call_tool()` method supports additional parameters for timeout control and progress monitoring:
+
+```python
+async with client:
+    # With timeout (aborts if execution takes longer than 2 seconds)
+    result = await client.call_tool(
+        "long_running_task", 
+        {"param": "value"}, 
+        timeout=2.0
+    )
+    
+    # With progress handler (to track execution progress)
+    result = await client.call_tool(
+        "long_running_task",
+        {"param": "value"},
+        progress_handler=my_progress_handler
+    )
+```
+
+**Parameters:**
+- `name`: The tool name (string)
+- `arguments`: Dictionary of arguments to pass to the tool (optional)
+- `timeout`: Maximum execution time in seconds (optional, overrides client-level timeout)
+- `progress_handler`: Progress callback function (optional, overrides client-level handler)
+
+## Handling Results
+
+Tool execution returns a list of content objects. The most common types are:
+
+- **`TextContent`**: Text-based results with a `.text` attribute
+- **`ImageContent`**: Image data with image-specific attributes
+- **`BlobContent`**: Binary data content
+
+```python
+async with client:
+    result = await client.call_tool("get_weather", {"city": "London"})
+    
+    for content in result:
+        if hasattr(content, 'text'):
+            print(f"Text result: {content.text}")
+        elif hasattr(content, 'data'):
+            print(f"Binary data: {len(content.data)} bytes")
+```
+
+## Error Handling
+
+### Exception-Based Error Handling
+
+By default, `call_tool()` raises a `ToolError` if the tool execution fails:
+
+```python
+from fastmcp.exceptions import ToolError
+
+async with client:
+    try:
+        result = await client.call_tool("potentially_failing_tool", {"param": "value"})
+        print("Tool succeeded:", result)
+    except ToolError as e:
+        print(f"Tool failed: {e}")
+```
+
+### Manual Error Checking
+
+For more granular control, use `call_tool_mcp()` which returns the raw MCP protocol object with an `isError` flag:
+
+```python
+async with client:
+    result = await client.call_tool_mcp("potentially_failing_tool", {"param": "value"})
+    # result -> mcp.types.CallToolResult
+    
+    if result.isError:
+        print(f"Tool failed: {result.content}")
+    else:
+        print(f"Tool succeeded: {result.content}")
+```
+
+## Argument Handling
+
+Arguments are passed as a dictionary to the tool:
+
+```python
+async with client:
+    # Simple arguments
+    result = await client.call_tool("greet", {"name": "World"})
+    
+    # Complex arguments
+    result = await client.call_tool("process_data", {
+        "config": {"format": "json", "validate": True},
+        "items": [1, 2, 3, 4, 5],
+        "metadata": {"source": "api", "version": "1.0"}
+    })
+```
+
+<Tip>
+For multi-server clients, tool names are automatically prefixed with the server name (e.g., `weather_get_forecast` for a tool named `get_forecast` on the `weather` server).
+</Tip>

docs/deployment/asgi.mdx

@@ -48,7 +48,7 @@ Both approaches return a Starlette application that can be integrated with other
 The returned app stores the `FastMCP` instance on `app.state.fastmcp_server`, so you
 can access it from custom middleware or routes via `request.app.state.fastmcp_server`.
 
-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:
+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
 # For Streamable HTTP transport
@@ -96,7 +96,13 @@ mcp = FastMCP("MyServer")
 
 # Define custom middleware
 custom_middleware = [
-    Middleware(CORSMiddleware, allow_origins=["*"]),
+    Middleware(
+        CORSMiddleware,
+        allow_origins=["https://example.com", "https://app.example.com"],
+        allow_credentials=True,
+        allow_methods=["GET", "POST", "OPTIONS"],
+        allow_headers=["Content-Type", "Authorization"],
+    ),
 ]
 
 # Create ASGI app with custom middleware
@@ -131,7 +137,7 @@ app = Starlette(
 )
 ```
 
-The MCP endpoint will be available at `/mcp-server/mcp` of the resulting Starlette app.
+The MCP endpoint will be available at `/mcp-server/mcp/` of the resulting Starlette app.
 
 <Warning>
 For Streamable HTTP transport, you **must** pass the lifespan context from the FastMCP app to the resulting Starlette app, as nested lifespans are not recognized. Otherwise, the FastMCP server's session manager will not be properly initialized.
@@ -161,7 +167,7 @@ app = Starlette(
 )
 ```
 
-In this setup, the MCP server is accessible at the `/outer/inner/mcp` path of the resulting Starlette app.
+In this setup, the MCP server is accessible at the `/outer/inner/mcp/` path of the resulting Starlette app.
 
 <Warning>
 For Streamable HTTP transport, you **must** pass the lifespan context from the FastMCP app to the *outer* Starlette app, as nested lifespans are not recognized. Otherwise, the FastMCP server's session manager will not be properly initialized.
@@ -188,7 +194,7 @@ app = FastAPI(lifespan=mcp_app.lifespan)
 app.mount("/mcp-server", mcp_app)
 ```
 
-The MCP endpoint will be available at `/mcp-server/mcp` of the resulting FastAPI app.
+The MCP endpoint will be available at `/mcp-server/mcp/` of the resulting FastAPI app.
 
 <Warning>
 For Streamable HTTP transport, you **must** pass the lifespan context from the FastMCP app to the resulting FastAPI app, as nested lifespans are not recognized. Otherwise, the FastMCP server's session manager will not be properly initialized.

docs/deployment/running-server.mdx

@@ -105,7 +105,7 @@ When using Stdio transport, you will typically *not* run the server yourself as
 
 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`).
+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>
 ```python {6} server.py
 from fastmcp import FastMCP
@@ -120,7 +120,7 @@ import asyncio
 from fastmcp import Client
 
 async def example():
-    async with Client("http://127.0.0.1:8000/mcp") as client:
+    async with Client("http://127.0.0.1:8000/mcp/") as client:
         await client.ping()
 
 if __name__ == "__main__":
@@ -168,7 +168,7 @@ New applications should use Streamable HTTP transport instead.
 
 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/`).
+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/`).
 
 <CodeGroup>
 ```python {6} server.py
@@ -186,7 +186,7 @@ from fastmcp.client.transports import SSETransport
 
 async def example():
     async with Client(
-        transport=SSETransport("http://127.0.0.1:8000/sse")
+        transport=SSETransport("http://127.0.0.1:8000/sse/")
     ) as client:
         await client.ping()
 

docs/docs.json

@@ -1,178 +1,296 @@
 {
-    "$schema": "https://mintlify.com/docs.json",
-    "appearance": {
-        "default": "system",
-        "strict": false
+  "$schema": "https://mintlify.com/docs.json",
+  "appearance": {
+    "default": "system",
+    "strict": false
+  },
+  "background": {
+    "color": {
+      "dark": "#222831",
+      "light": "#EEEEEE"
     },
-    "background": {
-        "color": {
-            "dark": "#222831",
-            "light": "#EEEEEE"
-        },
-        "decoration": "windows"
-    },
-    "banner": {
-        "content": "[FastMCP Cloud](https://fastmcp.link/x0Kyhy2) is coming!"
-    },
-    "colors": {
-        "dark": "#f72585",
-        "light": "#4cc9f0",
-        "primary": "#2d00f7"
-    },
-    "description": "The fast, Pythonic way to build MCP servers and clients.",
-    "favicon": {
-        "dark": "/assets/favicon.ico",
-        "light": "/assets/favicon.ico"
-    },
-    "footer": {
-        "socials": {
-            "bluesky": "https://bsky.app/profile/jlowin.dev",
-            "github": "https://github.com/jlowin/fastmcp",
-            "x": "https://x.com/jlowin"
-        }
-    },
-    "integrations": {
-        "ga4": {
-            "measurementId": "G-64R5W1TJXG"
-        }
-    },
-    "name": "FastMCP",
-    "navbar": {
-        "primary": {
-            "href": "https://github.com/jlowin/fastmcp",
-            "type": "github"
-        }
-    },
-    "navigation": {
+    "decoration": "windows"
+  },
+  "banner": {
+    "content": "[FastMCP Cloud](https://fastmcp.link/x0Kyhy2) is coming!"
+  },
+  "colors": {
+    "dark": "#f72585",
+    "light": "#4cc9f0",
+    "primary": "#2d00f7"
+  },
+  "description": "The fast, Pythonic way to build MCP servers and clients.",
+  "favicon": {
+    "dark": "/assets/favicon.ico",
+    "light": "/assets/favicon.ico"
+  },
+  "footer": {
+    "socials": {
+      "bluesky": "https://bsky.app/profile/jlowin.dev",
+      "github": "https://github.com/jlowin/fastmcp",
+      "x": "https://x.com/jlowin"
+    }
+  },
+  "integrations": {
+    "ga4": {
+      "measurementId": "G-64R5W1TJXG"
+    }
+  },
+  "name": "FastMCP",
+  "navbar": {
+    "primary": {
+      "href": "https://github.com/jlowin/fastmcp",
+      "type": "github"
+    }
+  },
+  "navigation": {
+    "tabs": [
+      {
+        "tab": "Documentation",
         "anchors": [
-            {
-                "anchor": "Documentation",
-                "groups": [
-                    {
-                        "group": "Get Started",
-                        "pages": [
-                            "getting-started/welcome",
-                            "getting-started/installation",
-                            "getting-started/quickstart",
-                            "updates"
-                        ]
-                    },
-                    {
-                        "group": "Servers",
-                        "pages": [
-                            "servers/fastmcp",
-                            {
-                                "group": "Core Components",
-                                "icon": "toolbox",
-                                "pages": [
-                                    "servers/tools",
-                                    "servers/resources",
-                                    "servers/prompts",
-                                    "servers/context"
-                                ]
-                            },
-                            {
-                                "group": "Authentication",
-                                "icon": "shield-check",
-                                "pages": [
-                                    "servers/auth/bearer"
-                                ]
-                            },
-                            "servers/middleware",
-                            "servers/openapi",
-                            "servers/proxy",
-                            "servers/composition",
-                            {
-                                "group": "Deployment",
-                                "icon": "upload",
-                                "pages": [
-                                    "deployment/running-server",
-                                    "deployment/asgi"
-                                ]
-                            }
-                        ]
-                    },
-                    {
-                        "group": "Clients",
-                        "pages": [
-                            "clients/client",
-                            "clients/transports",
-                            {
-                                "group": "Authentication",
-                                "icon": "user-shield",
-                                "pages": [
-                                    "clients/auth/oauth",
-                                    "clients/auth/bearer"
-                                ]
-                            },
-                            "clients/advanced-features"
-                        ]
-                    },
-                    {
-                        "group": "Integrations",
-                        "pages": [
-                            "integrations/anthropic",
-                            "integrations/claude-desktop",
-                            "integrations/openai",
-                            "integrations/gemini",
-                            "integrations/contrib"
-                        ]
-                    },
-                    {
-                        "group": "Patterns",
-                        "pages": [
-                            "patterns/tool-transformation",
-                            "patterns/decorating-methods",
-                            "patterns/http-requests",
-                            "patterns/testing",
-                            "patterns/cli"
-                        ]
-                    }
-                ],
-                "icon": "book"
-            },
-            {
-                "anchor": "Tutorials",
-                "groups": [
-                    {
-                        "group": "MCP",
+          {
+            "anchor": "Documentation",
+            "groups": [
+              {
+                "group": "Get Started",
+                "pages": [
+                  "getting-started/welcome",
+                  "getting-started/installation",
+                  "getting-started/quickstart"
+                ]
+              },
+              {
+                "group": "Servers",
+                "pages": [
+                  "servers/server",
+                  {
+                    "group": "Core Components",
+                    "icon": "toolbox",
+                    "pages": [
+                      "servers/tools",
+                      "servers/resources",
+                      "servers/prompts",
+                      "servers/context"
+                    ]
+                  },
+                  {
+                    "group": "Authentication",
+                    "icon": "shield-check",
+                    "pages": ["servers/auth/bearer"]
+                  },
+                  "servers/middleware",
+                  "servers/openapi",
+                  "servers/proxy",
+                  "servers/composition",
+                  {
+                    "group": "Deployment",
+                    "icon": "upload",
+                    "pages": ["deployment/running-server", "deployment/asgi"]
+                  }
+                ]
+              },
+              {
+                "group": "Clients",
+                "pages": [
+                  "clients/client",
+                  {
+                    "group": "Core Operations",
+                    "icon": "handshake",
+                    "pages": [
+                      "clients/tools",
+                      "clients/resources",
+                      "clients/prompts"
+                    ]
+                  },
+                  {
+                    "group": "Advanced Features",
+                    "icon": "stars",
+                    "pages": [
+                      "clients/logging",
+                      "clients/progress",
+                      "clients/sampling",
+                      "clients/roots"
+                    ]
+                  },
+                  "clients/transports",
+                  {
+                    "group": "Authentication",
+                    "icon": "user-shield",
+                    "pages": ["clients/auth/oauth", "clients/auth/bearer"]
+                  }
+                ]
+              },
+              {
+                "group": "Integrations",
+                "pages": [
+                  "integrations/anthropic",
+                  "integrations/claude-desktop",
+                  "integrations/openai",
+                  "integrations/gemini",
+                  "integrations/contrib"
+                ]
+              },
+              {
+                "group": "Patterns",
+                "pages": [
+                  "patterns/tool-transformation",
+                  "patterns/decorating-methods",
+                  "patterns/http-requests",
+                  "patterns/testing",
+                  "patterns/cli"
+                ]
+              },
+              {
+                "group": "Tutorials",
+                "pages": [
+                  "tutorials/mcp",
+                  "tutorials/create-mcp-server",
+                  "tutorials/rest-api"
+                ]
+              }
+            ],
+            "icon": "book"
+          },
+          {
+            "anchor": "What's New",
+            "pages": ["updates", "changelog"]
+          },
+
+          {
+            "anchor": "Community",
+            "icon": "users",
+            "pages": ["community/showcase"]
+          }
+        ]
+      },
+      {
+        "tab": "SDK Reference",
+        "anchors": [
+          {
+            "anchor": "Python SDK",
+            "icon": "python",
+            "pages": [
+              "python-sdk/fastmcp-exceptions",
+              "python-sdk/fastmcp-settings",
+              {
+                "group": "fastmcp.cli",
+                "pages": [
+                  "python-sdk/fastmcp-cli-__init__",
+                  "python-sdk/fastmcp-cli-claude",
+                  "python-sdk/fastmcp-cli-cli",
+                  "python-sdk/fastmcp-cli-run"
+                ]
+              },
+              {
+                "group": "fastmcp.client",
+                "pages": [
+                  "python-sdk/fastmcp-client-__init__",
+                  {
+                    "group": "auth",
+                    "pages": [
+                      "python-sdk/fastmcp-client-auth-__init__",
+                      "python-sdk/fastmcp-client-auth-bearer",
+                      "python-sdk/fastmcp-client-auth-oauth"
+                    ]
+                  },
+                  "python-sdk/fastmcp-client-client",
+                  "python-sdk/fastmcp-client-logging",
+                  "python-sdk/fastmcp-client-oauth_callback",
+                  "python-sdk/fastmcp-client-progress",
+                  "python-sdk/fastmcp-client-roots",
+                  "python-sdk/fastmcp-client-sampling",
+                  "python-sdk/fastmcp-client-transports"
+                ]
+              },
+              {
+                "group": "fastmcp.prompts",
+                "pages": [
+                  "python-sdk/fastmcp-prompts-__init__",
+                  "python-sdk/fastmcp-prompts-prompt",
+                  "python-sdk/fastmcp-prompts-prompt_manager"
+                ]
+              },
+              {
+                "group": "fastmcp.resources",
+                "pages": [
+                  "python-sdk/fastmcp-resources-__init__",
+                  "python-sdk/fastmcp-resources-resource",
+                  "python-sdk/fastmcp-resources-resource_manager",
+                  "python-sdk/fastmcp-resources-template",
+                  "python-sdk/fastmcp-resources-types"
+                ]
+              },
+              {
+                "group": "fastmcp.server",
+                "pages": [
+                  "python-sdk/fastmcp-server-__init__",
+                  {
+                    "group": "auth",
+                    "pages": [
+                      "python-sdk/fastmcp-server-auth-__init__",
+                      "python-sdk/fastmcp-server-auth-auth",
+                      {
+                        "group": "providers",
                         "pages": [
-                            "tutorials/mcp",
-                            "tutorials/create-mcp-server",
-                            "tutorials/rest-api"
+                          "python-sdk/fastmcp-server-auth-providers-__init__",
+                          "python-sdk/fastmcp-server-auth-providers-bearer",
+                          "python-sdk/fastmcp-server-auth-providers-bearer_env",
+                          "python-sdk/fastmcp-server-auth-providers-in_memory"
                         ]
-                    }
-                ],
-                "icon": "graduation-cap"
-            },
-            {
-                "anchor": "Changelog",
-                "icon": "list-check",
+                      }
+                    ]
+                  },
+                  "python-sdk/fastmcp-server-context",
+                  "python-sdk/fastmcp-server-dependencies",
+                  "python-sdk/fastmcp-server-http",
+                  "python-sdk/fastmcp-server-middleware",
+                  "python-sdk/fastmcp-server-openapi",
+                  "python-sdk/fastmcp-server-proxy",
+                  "python-sdk/fastmcp-server-server"
+                ]
+              },
+              {
+                "group": "fastmcp.tools",
                 "pages": [
-                    "changelog"
+                  "python-sdk/fastmcp-tools-__init__",
+                  "python-sdk/fastmcp-tools-tool",
+                  "python-sdk/fastmcp-tools-tool_manager",
+                  "python-sdk/fastmcp-tools-tool_transform"
                 ]
-            },
-            {
-                "anchor": "Community",
-                "icon": "users",
+              },
+              {
+                "group": "fastmcp.utilities",
                 "pages": [
-                    "community/showcase"
+                  "python-sdk/fastmcp-utilities-__init__",
+                  "python-sdk/fastmcp-utilities-cache",
+                  "python-sdk/fastmcp-utilities-components",
+                  "python-sdk/fastmcp-utilities-exceptions",
+                  "python-sdk/fastmcp-utilities-http",
+                  "python-sdk/fastmcp-utilities-json_schema",
+                  "python-sdk/fastmcp-utilities-logging",
+                  "python-sdk/fastmcp-utilities-mcp_config",
+                  "python-sdk/fastmcp-utilities-openapi",
+                  "python-sdk/fastmcp-utilities-types"
                 ]
-            }
+              }
+            ]
+          }
         ]
+      }
+    ]
+  },
+  "redirects": [
+    {
+      "destination": "/servers/proxy",
+      "source": "/patterns/proxy"
     },
-    "redirects": [
-        {
-            "destination": "/servers/proxy",
-            "source": "/patterns/proxy"
-        },
-        {
-            "destination": "/servers/composition",
-            "source": "/patterns/composition"
-        }
-    ],
-    "search": {
-        "prompt": "Search the docs..."
-    },
-    "theme": "mint"
-}
+    {
+      "destination": "/servers/composition",
+      "source": "/patterns/composition"
+    }
+  ],
+  "search": {
+    "prompt": "Search the docs..."
+  },
+  "theme": "mint"
+}

docs/integrations/anthropic.mdx

@@ -3,7 +3,7 @@ title: Anthropic API + FastMCP
 sidebarTitle: Anthropic API
 description: Call FastMCP servers from the Anthropic API
 icon: message-smile
-tag: "New!"
+tag: NEW
 ---
 
 import { VersionBadge } from "/snippets/version-badge.mdx"

docs/integrations/gemini.mdx

@@ -3,7 +3,7 @@ title: Gemini SDK + FastMCP
 sidebarTitle: Gemini SDK
 description: Call FastMCP servers from the Google Gemini SDK
 icon: message-smile
-tag: "New!"
+tag: NEW
 ---
 
 import { VersionBadge } from "/snippets/version-badge.mdx"

docs/integrations/openai.mdx

@@ -3,7 +3,7 @@ title: OpenAI API + FastMCP
 sidebarTitle: OpenAI API
 description: Call FastMCP servers from the OpenAI API
 icon: message-smile
-tag: "New!"
+tag: NEW
 ---
 
 import { VersionBadge } from "/snippets/version-badge.mdx"

docs/patterns/cli.mdx

@@ -21,6 +21,7 @@ fastmcp --help
 | `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` |
+| `inspect` | Generate a JSON report about a FastMCP server | Uses your current environment; you are responsible for ensuring all dependencies are available |
 | `version` | Display version information | N/A |
 
 ## Command Details
@@ -179,6 +180,29 @@ fastmcp install server.py:my_server
 fastmcp install server.py:my_server -n "My Analysis Server" --with pandas
 ```
 
+### `inspect`
+
+<VersionBadge version="2.9.0" />
+
+Generate a detailed JSON report about a FastMCP server, including information about its tools, prompts, resources, and capabilities.
+
+```bash
+fastmcp inspect server.py
+```
+
+The command supports the same server specification format as `run` and `install`:
+
+```bash
+# Auto-detect server object
+fastmcp inspect server.py
+
+# Specify server object
+fastmcp inspect server.py:my_server
+
+# Custom output location
+fastmcp inspect server.py --output analysis.json
+```
+
 ### `version`
 
 Display version information about FastMCP and related components.

docs/python-sdk/fastmcp-cli-__init__.mdx

@@ -0,0 +1,9 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.cli`
+
+
+FastMCP CLI package.

docs/python-sdk/fastmcp-cli-claude.mdx

@@ -0,0 +1,43 @@
+---
+title: claude
+sidebarTitle: claude
+---
+
+# `fastmcp.cli.claude`
+
+
+Claude app integration utilities.
+
+## Functions
+
+### `get_claude_config_path`
+
+```python
+get_claude_config_path() -> Path | None
+```
+
+
+Get the Claude config directory based on platform.
+
+
+### `update_claude_config`
+
+```python
+update_claude_config(file_spec: str, server_name: str) -> bool
+```
+
+
+Add or update a FastMCP server in Claude's configuration.
+
+**Args:**
+- `file_spec`: Path to the server file, optionally with \:object suffix
+- `server_name`: Name for the server in Claude's config
+- `with_editable`: Optional directory to install in editable mode
+- `with_packages`: Optional list of additional packages to install
+- `env_vars`: Optional dictionary of environment variables. These are merged with
+any existing variables, with new values taking precedence.
+
+**Raises:**
+- `RuntimeError`: If Claude Desktop's config directory is not found, indicating
+Claude Desktop may not be installed or properly set up.
+

docs/python-sdk/fastmcp-cli-cli.mdx

@@ -0,0 +1,65 @@
+---
+title: cli
+sidebarTitle: cli
+---
+
+# `fastmcp.cli.cli`
+
+
+FastMCP CLI tools.
+
+## Functions
+
+### `version`
+
+```python
+version(ctx: Context)
+```
+
+### `dev`
+
+```python
+dev(server_spec: str = typer.Argument(..., help='Python file to run, optionally with :object suffix'), with_editable: Annotated[Path | None, typer.Option('--with-editable', '-e', help='Directory containing pyproject.toml to install in editable mode', exists=True, file_okay=False, resolve_path=True)] = None, with_packages: Annotated[list[str], typer.Option('--with', help='Additional packages to install')] = [], inspector_version: Annotated[str | None, typer.Option('--inspector-version', help='Version of the MCP Inspector to use')] = None, ui_port: Annotated[int | None, typer.Option('--ui-port', help='Port for the MCP Inspector UI')] = None, server_port: Annotated[int | None, typer.Option('--server-port', help='Port for the MCP Inspector Proxy server')] = None) -> None
+```
+
+
+Run a MCP server with the MCP Inspector.
+
+
+### `run`
+
+```python
+run(ctx: typer.Context, server_spec: str = typer.Argument(..., help='Python file, object specification (file:obj), or URL'), transport: Annotated[str | None, typer.Option('--transport', '-t', help='Transport protocol to use (stdio, streamable-http, or sse)')] = None, host: Annotated[str | None, typer.Option('--host', help='Host to bind to when using http transport (default: 127.0.0.1)')] = None, port: Annotated[int | None, typer.Option('--port', '-p', help='Port to bind to when using http transport (default: 8000)')] = None, log_level: Annotated[str | None, typer.Option('--log-level', '-l', help='Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)')] = None) -> None
+```
+
+
+Run a MCP server or connect to a remote one.
+
+The server can be specified in three ways:
+1. Module approach: server.py - runs the module directly, looking for an object named mcp/server/app.
+
+2. Import approach: server.py:app - imports and runs the specified server object.
+
+3. URL approach: http://server-url - connects to a remote server and creates a proxy.
+
+
+
+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
+
+
+### `install`
+
+```python
+install(server_spec: str = typer.Argument(..., help='Python file to run, optionally with :object suffix'), server_name: Annotated[str | None, typer.Option('--name', '-n', help="Custom name for the server (defaults to server's name attribute or file name)")] = None, with_editable: Annotated[Path | None, typer.Option('--with-editable', '-e', help='Directory containing pyproject.toml to install in editable mode', exists=True, file_okay=False, resolve_path=True)] = None, with_packages: Annotated[list[str], typer.Option('--with', help='Additional packages to install')] = [], env_vars: Annotated[list[str], typer.Option('--env-var', '-v', help='Environment variables in KEY=VALUE format')] = [], env_file: Annotated[Path | None, typer.Option('--env-file', '-f', help='Load environment variables from a .env file', exists=True, file_okay=True, dir_okay=False, resolve_path=True)] = None) -> None
+```
+
+
+Install a MCP server in the Claude desktop app.
+
+Environment variables are preserved once added and only updated if new values
+are explicitly provided.
+

docs/python-sdk/fastmcp-cli-run.mdx

@@ -0,0 +1,106 @@
+---
+title: run
+sidebarTitle: run
+---
+
+# `fastmcp.cli.run`
+
+
+FastMCP run command implementation.
+
+## Functions
+
+### `is_url`
+
+```python
+is_url(path: str) -> bool
+```
+
+
+Check if a string is a URL.
+
+
+### `parse_file_path`
+
+```python
+parse_file_path(server_spec: str) -> tuple[Path, str | None]
+```
+
+
+Parse a file path that may include a server object specification.
+
+**Args:**
+- `server_spec`: Path to file, optionally with \:object suffix
+
+**Returns:**
+- Tuple of (file_path, server_object)
+
+
+### `import_server`
+
+```python
+import_server(file: Path, server_object: str | None = None) -> Any
+```
+
+
+Import a MCP server from a file.
+
+**Args:**
+- `file`: Path to the file
+- `server_object`: Optional object name in format "module\:object" or just "object"
+
+**Returns:**
+- The server object
+
+
+### `create_client_server`
+
+```python
+create_client_server(url: str) -> Any
+```
+
+
+Create a FastMCP server from a client URL.
+
+**Args:**
+- `url`: The URL to connect to
+
+**Returns:**
+- A FastMCP server instance
+
+
+### `import_server_with_args`
+
+```python
+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
+
+
+### `run_command`
+
+```python
+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.
+
+**Args:**
+- `server_spec`: Python file, object specification (file\:obj), or URL
+- `transport`: Transport protocol to use
+- `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
+

docs/python-sdk/fastmcp-client-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.client`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-client-auth-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.client.auth`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-client-auth-bearer.mdx

@@ -0,0 +1,18 @@
+---
+title: bearer
+sidebarTitle: bearer
+---
+
+# `fastmcp.client.auth.bearer`
+
+## Classes
+
+### `BearerAuth`
+
+**Methods:**
+
+#### `auth_flow`
+
+```python
+auth_flow(self, request)
+```

docs/python-sdk/fastmcp-client-auth-oauth.mdx

@@ -0,0 +1,102 @@
+---
+title: oauth
+sidebarTitle: oauth
+---
+
+# `fastmcp.client.auth.oauth`
+
+## Functions
+
+### `default_cache_dir`
+
+```python
+default_cache_dir() -> Path
+```
+
+### `OAuth`
+
+```python
+OAuth(mcp_url: str, scopes: str | list[str] | None = None, client_name: str = 'FastMCP Client', token_storage_cache_dir: Path | None = None, additional_client_metadata: dict[str, Any] | None = None) -> _MCPOAuthClientProvider
+```
+
+
+Create an OAuthClientProvider for an MCP server.
+
+This is intended to be provided to the `auth` parameter of an
+httpx.AsyncClient (or appropriate FastMCP client/transport instance)
+
+**Args:**
+- `mcp_url`: Full URL to the MCP endpoint (e.g. "http\://host/mcp/sse/")
+- `scopes`: OAuth scopes to request. Can be a
+- `client_name`: Name for this client during registration
+- `token_storage_cache_dir`: Directory for FileTokenStorage
+- `additional_client_metadata`: Extra fields for OAuthClientMetadata
+
+**Returns:**
+- OAuthClientProvider
+
+
+## Classes
+
+### `ServerOAuthMetadata`
+
+
+More flexible OAuth metadata model that accepts broader ranges of values
+than the restrictive MCP standard model.
+
+This handles real-world OAuth servers like PayPal that may support
+additional methods not in the MCP specification.
+
+
+### `OAuthClientProvider`
+
+
+OAuth client provider with more flexible OAuth metadata discovery.
+
+
+### `FileTokenStorage`
+
+
+File-based token storage implementation for OAuth credentials and tokens.
+Implements the mcp.client.auth.TokenStorage protocol.
+
+Each instance is tied to a specific server URL for proper token isolation.
+
+
+**Methods:**
+
+#### `get_base_url`
+
+```python
+get_base_url(url: str) -> str
+```
+
+Extract the base URL (scheme + host) from a URL.
+
+
+#### `get_cache_key`
+
+```python
+get_cache_key(self) -> str
+```
+
+Generate a safe filesystem key from the server's base URL.
+
+
+#### `clear`
+
+```python
+clear(self) -> None
+```
+
+Clear all cached data for this server.
+
+
+#### `clear_all`
+
+```python
+clear_all(cls, cache_dir: Path | None = None) -> None
+```
+
+Clear all cached data for all servers.
+

docs/python-sdk/fastmcp-client-client.mdx

@@ -0,0 +1,94 @@
+---
+title: client
+sidebarTitle: client
+---
+
+# `fastmcp.client.client`
+
+## Classes
+
+### `Client`
+
+
+
+    MCP client that delegates connection management to a Transport instance.
+
+    The Client class is responsible for MCP protocol logic, while the Transport
+    handles connection establishment and management. Client provides methods for
+    working with resources, prompts, tools and other MCP capabilities.
+
+    Args:
+        transport: Connection source specification, which can be:
+            - ClientTransport: Direct transport instance
+            - FastMCP: In-process FastMCP server
+            - AnyUrl | str: URL to connect to
+            - Path: File path for local socket
+            - MCPConfig: MCP server configuration
+            - dict: Transport configuration
+        roots: Optional RootsList or RootsHandler for filesystem access
+        sampling_handler: Optional handler for sampling requests
+        log_handler: Optional handler for log messages
+        message_handler: Optional handler for protocol messages
+        progress_handler: Optional handler for progress notifications
+        timeout: Optional timeout for requests (seconds or timedelta)
+        init_timeout: Optional timeout for initial connection (seconds or timedelta).
+            Set to 0 to disable. If None, uses the value in the FastMCP global settings.
+
+    Examples:
+        ```python # Connect to FastMCP server client =
+        Client("http://localhost:8080")
+
+        async with client:
+            # List available resources resources = await client.list_resources()
+
+            # Call a tool result = await client.call_tool("my_tool", {"param":
+            "value"})
+        ```
+    
+
+**Methods:**
+
+#### `session`
+
+```python
+session(self) -> ClientSession
+```
+
+Get the current active session. Raises RuntimeError if not connected.
+
+
+#### `initialize_result`
+
+```python
+initialize_result(self) -> mcp.types.InitializeResult
+```
+
+Get the result of the initialization request.
+
+
+#### `set_roots`
+
+```python
+set_roots(self, roots: RootsList | RootsHandler) -> None
+```
+
+Set the roots for the client. This does not automatically call `send_roots_list_changed`.
+
+
+#### `set_sampling_callback`
+
+```python
+set_sampling_callback(self, sampling_callback: SamplingHandler) -> None
+```
+
+Set the sampling callback for the client.
+
+
+#### `is_connected`
+
+```python
+is_connected(self) -> bool
+```
+
+Check if the client is currently connected.
+

docs/python-sdk/fastmcp-client-logging.mdx

@@ -0,0 +1,14 @@
+---
+title: logging
+sidebarTitle: logging
+---
+
+# `fastmcp.client.logging`
+
+## Functions
+
+### `create_log_callback`
+
+```python
+create_log_callback(handler: LogHandler | None = None) -> LoggingFnT
+```

docs/python-sdk/fastmcp-client-oauth_callback.mdx

@@ -0,0 +1,63 @@
+---
+title: oauth_callback
+sidebarTitle: oauth_callback
+---
+
+# `fastmcp.client.oauth_callback`
+
+
+
+OAuth callback server for handling authorization code flows.
+
+This module provides a reusable callback server that can handle OAuth redirects
+and display styled responses to users.
+
+
+## Functions
+
+### `create_callback_html`
+
+```python
+create_callback_html(message: str, is_success: bool = True, title: str = 'FastMCP OAuth', server_url: str | None = None) -> str
+```
+
+
+Create a styled HTML response for OAuth callbacks.
+
+
+### `create_oauth_callback_server`
+
+```python
+create_oauth_callback_server(port: int, callback_path: str = '/callback', server_url: str | None = None, response_future: asyncio.Future | None = None) -> Server
+```
+
+
+Create an OAuth callback server.
+
+**Args:**
+- `port`: The port to run the server on
+- `callback_path`: The path to listen for OAuth redirects on
+- `server_url`: Optional server URL to display in success messages
+- `response_future`: Optional future to resolve when OAuth callback is received
+
+**Returns:**
+- Configured uvicorn Server instance (not yet running)
+
+
+## Classes
+
+### `CallbackResponse`
+
+**Methods:**
+
+#### `from_dict`
+
+```python
+from_dict(cls, data: dict[str, str]) -> CallbackResponse
+```
+
+#### `to_dict`
+
+```python
+to_dict(self) -> dict[str, str]
+```

docs/python-sdk/fastmcp-client-progress.mdx

@@ -0,0 +1,8 @@
+---
+title: progress
+sidebarTitle: progress
+---
+
+# `fastmcp.client.progress`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-client-roots.mdx

@@ -0,0 +1,20 @@
+---
+title: roots
+sidebarTitle: roots
+---
+
+# `fastmcp.client.roots`
+
+## Functions
+
+### `convert_roots_list`
+
+```python
+convert_roots_list(roots: RootsList) -> list[mcp.types.Root]
+```
+
+### `create_roots_callback`
+
+```python
+create_roots_callback(handler: RootsList | RootsHandler) -> ListRootsFnT
+```

docs/python-sdk/fastmcp-client-sampling.mdx

@@ -0,0 +1,14 @@
+---
+title: sampling
+sidebarTitle: sampling
+---
+
+# `fastmcp.client.sampling`
+
+## Functions
+
+### `create_sampling_callback`
+
+```python
+create_sampling_callback(sampling_handler: SamplingHandler) -> SamplingFnT
+```

docs/python-sdk/fastmcp-client-transports.mdx

@@ -0,0 +1,191 @@
+---
+title: transports
+sidebarTitle: transports
+---
+
+# `fastmcp.client.transports`
+
+## Functions
+
+### `infer_transport`
+
+```python
+infer_transport(transport: ClientTransport | FastMCP | FastMCP1Server | AnyUrl | Path | MCPConfig | dict[str, Any] | str) -> ClientTransport
+```
+
+
+
+    Infer the appropriate transport type from the given transport argument.
+
+    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.
+
+    The function supports these input types:
+    - ClientTransport: Used directly without modification
+    - FastMCP or FastMCP1Server: Creates an in-memory FastMCPTransport
+    - Path or str (file path): Creates PythonStdioTransport (.py) or NodeStdioTransport (.js)
+    - AnyUrl or str (URL): Creates StreamableHttpTransport (default) or SSETransport (for /sse endpoints)
+    - MCPConfig or dict: Creates MCPConfigTransport, potentially connecting to multiple servers
+
+    For HTTP URLs, they are assumed to be Streamable HTTP URLs unless they end in `/sse`.
+
+    For MCPConfig with multiple servers, a composite client is created where each server
+    is mounted with its name as prefix. This allows accessing tools and resources from multiple
+    servers through a single unified client interface, using naming patterns like
+    `servername_toolname` for tools and `protocol://servername/path` for resources.
+    If the MCPConfig contains only one server, a direct connection is established without prefixing.
+
+    Examples:
+        ```python
+        # Connect to a local Python script
+        transport = infer_transport("my_script.py")
+
+        # Connect to a remote server via HTTP
+        transport = infer_transport("http://example.com/mcp")
+
+        # Connect to multiple servers using MCPConfig
+        config = {
+            "mcpServers": {
+                "weather": {"url": "http://weather.example.com/mcp"},
+                "calendar": {"url": "http://calendar.example.com/mcp"}
+            }
+        }
+        transport = infer_transport(config)
+        ```
+    
+
+## Classes
+
+### `SessionKwargs`
+
+
+Keyword arguments for the MCP ClientSession constructor.
+
+
+### `ClientTransport`
+
+
+Abstract base class for different MCP client transport mechanisms.
+
+A Transport is responsible for establishing and managing connections
+to an MCP server, and providing a ClientSession within an async context.
+
+
+### `WSTransport`
+
+
+Transport implementation that connects to an MCP server via WebSockets.
+
+
+### `SSETransport`
+
+
+Transport implementation that connects to an MCP server via Server-Sent Events.
+
+
+### `StreamableHttpTransport`
+
+
+Transport implementation that connects to an MCP server via Streamable HTTP Requests.
+
+
+### `StdioTransport`
+
+
+Base transport for connecting to an MCP server via subprocess with stdio.
+
+This is a base class that can be subclassed for specific command-based
+transports like Python, Node, Uvx, etc.
+
+
+### `PythonStdioTransport`
+
+
+Transport for running Python scripts.
+
+
+### `FastMCPStdioTransport`
+
+
+Transport for running FastMCP servers using the FastMCP CLI.
+
+
+### `NodeStdioTransport`
+
+
+Transport for running Node.js scripts.
+
+
+### `UvxStdioTransport`
+
+
+Transport for running commands via the uvx tool.
+
+
+### `NpxStdioTransport`
+
+
+Transport for running commands via the npx tool.
+
+
+### `FastMCPTransport`
+
+
+In-memory transport for FastMCP servers.
+
+This transport connects directly to a FastMCP server instance in the same
+Python process. It works with both FastMCP 2.x servers and FastMCP 1.0
+servers from the low-level MCP SDK. This is particularly useful for unit
+tests or scenarios where client and server run in the same runtime.
+
+
+### `MCPConfigTransport`
+
+
+Transport for connecting to one or more MCP servers defined in an MCPConfig.
+
+    This transport provides a unified interface to multiple MCP servers defined in an MCPConfig
+    object or dictionary matching the MCPConfig schema. It supports two key scenarios:
+
+    1. If the MCPConfig contains exactly one server, it creates a direct transport to that server.
+    2. If the MCPConfig contains multiple servers, it creates a composite client by mounting
+       all servers on a single FastMCP instance, with each server's name used as its mounting prefix.
+
+    In the multi-server case, tools are accessible with the prefix pattern `{server_name}_{tool_name}`
+    and resources with the pattern `protocol://{server_name}/path/to/resource`.
+
+    This is particularly useful for creating clients that need to interact with multiple specialized
+    MCP servers through a single interface, simplifying client code.
+
+    Examples:
+        ```python
+        from fastmcp import Client
+        from fastmcp.utilities.mcp_config import MCPConfig
+
+        # Create a config with multiple servers
+        config = {
+            "mcpServers": {
+                "weather": {
+                    "url": "https://weather-api.example.com/mcp",
+                    "transport": "streamable-http"
+                },
+                "calendar": {
+                    "url": "https://calendar-api.example.com/mcp",
+                    "transport": "streamable-http"
+                }
+            }
+        }
+
+        # Create a client with the config
+        client = Client(config)
+
+        async with client:
+            # Access tools with prefixes
+            weather = await client.call_tool("weather_get_forecast", {"city": "London"})
+            events = await client.call_tool("calendar_list_events", {"date": "2023-06-01"})
+
+            # Access resources with prefixed URIs
+            icons = await client.read_resource("weather://weather/icons/sunny")
+        ```
+    

docs/python-sdk/fastmcp-exceptions.mdx

@@ -0,0 +1,65 @@
+---
+title: exceptions
+sidebarTitle: exceptions
+---
+
+# `fastmcp.exceptions`
+
+
+Custom exceptions for FastMCP.
+
+## Classes
+
+### `FastMCPError`
+
+
+Base error for FastMCP.
+
+
+### `ValidationError`
+
+
+Error in validating parameters or return values.
+
+
+### `ResourceError`
+
+
+Error in resource operations.
+
+
+### `ToolError`
+
+
+Error in tool operations.
+
+
+### `PromptError`
+
+
+Error in prompt operations.
+
+
+### `InvalidSignature`
+
+
+Invalid signature for use with FastMCP.
+
+
+### `ClientError`
+
+
+Error in client operations.
+
+
+### `NotFoundError`
+
+
+Object not found.
+
+
+### `DisabledError`
+
+
+Object is disabled.
+

docs/python-sdk/fastmcp-prompts-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.prompts`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-prompts-prompt.mdx

@@ -0,0 +1,84 @@
+---
+title: prompt
+sidebarTitle: prompt
+---
+
+# `fastmcp.prompts.prompt`
+
+
+Base classes for FastMCP prompts.
+
+## Functions
+
+### `Message`
+
+```python
+Message(content: str | MCPContent, role: Role | None = None, **kwargs: Any) -> PromptMessage
+```
+
+
+A user-friendly constructor for PromptMessage.
+
+
+## Classes
+
+### `PromptArgument`
+
+
+An argument that can be passed to a prompt.
+
+
+### `Prompt`
+
+
+A prompt template that can be rendered with parameters.
+
+
+**Methods:**
+
+#### `to_mcp_prompt`
+
+```python
+to_mcp_prompt(self, **overrides: Any) -> MCPPrompt
+```
+
+Convert the prompt to an MCP prompt.
+
+
+#### `from_function`
+
+```python
+from_function(fn: Callable[..., PromptResult | Awaitable[PromptResult]], name: str | None = None, description: str | None = None, tags: set[str] | None = None, enabled: bool | 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
+
+
+### `FunctionPrompt`
+
+
+A prompt that is a function.
+
+
+**Methods:**
+
+#### `from_function`
+
+```python
+from_function(cls, fn: Callable[..., PromptResult | Awaitable[PromptResult]], name: str | None = None, description: str | None = None, tags: set[str] | None = None, enabled: bool | 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
+

docs/python-sdk/fastmcp-prompts-prompt_manager.mdx

@@ -0,0 +1,43 @@
+---
+title: prompt_manager
+sidebarTitle: prompt_manager
+---
+
+# `fastmcp.prompts.prompt_manager`
+
+## Classes
+
+### `PromptManager`
+
+
+Manages FastMCP prompts.
+
+
+**Methods:**
+
+#### `mount`
+
+```python
+mount(self, server: MountedServer) -> None
+```
+
+Adds a mounted server as a source for prompts.
+
+
+#### `add_prompt_from_fn`
+
+```python
+add_prompt_from_fn(self, 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.
+
+
+#### `add_prompt`
+
+```python
+add_prompt(self, prompt: Prompt) -> Prompt
+```
+
+Add a prompt to the manager.
+

docs/python-sdk/fastmcp-resources-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.resources`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-resources-resource.mdx

@@ -0,0 +1,90 @@
+---
+title: resource
+sidebarTitle: resource
+---
+
+# `fastmcp.resources.resource`
+
+
+Base classes and interfaces for FastMCP resources.
+
+## Classes
+
+### `Resource`
+
+
+Base class for all resources.
+
+
+**Methods:**
+
+#### `from_function`
+
+```python
+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, enabled: bool | None = None) -> FunctionResource
+```
+
+#### `set_default_mime_type`
+
+```python
+set_default_mime_type(cls, mime_type: str | None) -> str
+```
+
+Set default MIME type if not provided.
+
+
+#### `set_default_name`
+
+```python
+set_default_name(self) -> Self
+```
+
+Set default name from URI if not provided.
+
+
+#### `to_mcp_resource`
+
+```python
+to_mcp_resource(self, **overrides: Any) -> MCPResource
+```
+
+Convert the resource to an MCPResource.
+
+
+#### `key`
+
+```python
+key(self) -> str
+```
+
+The key of the component. This is used for internal bookkeeping
+and may reflect e.g. prefixes or other identifiers. You should not depend on
+keys having a certain value, as the same tool loaded from different
+hierarchies of servers may have different keys.
+
+
+### `FunctionResource`
+
+
+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
+
+
+**Methods:**
+
+#### `from_function`
+
+```python
+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, enabled: bool | None = None) -> FunctionResource
+```
+
+Create a FunctionResource from a function.
+

docs/python-sdk/fastmcp-resources-resource_manager.mdx

@@ -0,0 +1,111 @@
+---
+title: resource_manager
+sidebarTitle: resource_manager
+---
+
+# `fastmcp.resources.resource_manager`
+
+
+Resource manager functionality.
+
+## Classes
+
+### `ResourceManager`
+
+
+Manages FastMCP resources.
+
+
+**Methods:**
+
+#### `mount`
+
+```python
+mount(self, server: MountedServer) -> None
+```
+
+Adds a mounted server as a source for resources and templates.
+
+
+#### `add_resource_or_template_from_fn`
+
+```python
+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:**
+- `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.
+
+
+#### `add_resource_from_fn`
+
+```python
+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.
+
+
+#### `add_resource`
+
+```python
+add_resource(self, resource: Resource) -> Resource
+```
+
+Add a resource to the manager.
+
+**Args:**
+- `resource`: A Resource instance to add. The resource's .key attribute
+will be used as the storage key. To overwrite it, call
+Resource.with_key() before calling this method.
+
+
+#### `add_template_from_fn`
+
+```python
+add_template_from_fn(self, fn: Callable[..., Any], uri_template: str, name: str | None = None, description: str | None = None, mime_type: str | None = None, tags: set[str] | None = None) -> ResourceTemplate
+```
+
+Create a template from a function.
+
+
+#### `add_template`
+
+```python
+add_template(self, template: ResourceTemplate) -> ResourceTemplate
+```
+
+Add a template to the manager.
+
+**Args:**
+- `template`: A ResourceTemplate instance to add. The template's .key attribute
+will be used as the storage key. To overwrite it, call
+ResourceTemplate.with_key() before calling this method.
+
+**Returns:**
+- The added template. If a template with the same URI already exists,
+- returns the existing template.
+

docs/python-sdk/fastmcp-resources-template.mdx

@@ -0,0 +1,104 @@
+---
+title: template
+sidebarTitle: template
+---
+
+# `fastmcp.resources.template`
+
+
+Resource template functionality.
+
+## Functions
+
+### `build_regex`
+
+```python
+build_regex(template: str) -> re.Pattern
+```
+
+### `match_uri_template`
+
+```python
+match_uri_template(uri: str, uri_template: str) -> dict[str, str] | None
+```
+
+## Classes
+
+### `ResourceTemplate`
+
+
+A template for dynamically creating resources.
+
+
+**Methods:**
+
+#### `from_function`
+
+```python
+from_function(fn: Callable[..., Any], uri_template: str, name: str | None = None, description: str | None = None, mime_type: str | None = None, tags: set[str] | None = None, enabled: bool | None = None) -> FunctionResourceTemplate
+```
+
+#### `set_default_mime_type`
+
+```python
+set_default_mime_type(cls, mime_type: str | None) -> str
+```
+
+Set default MIME type if not provided.
+
+
+#### `matches`
+
+```python
+matches(self, uri: str) -> dict[str, Any] | None
+```
+
+Check if URI matches template and extract parameters.
+
+
+#### `to_mcp_template`
+
+```python
+to_mcp_template(self, **overrides: Any) -> MCPResourceTemplate
+```
+
+Convert the resource template to an MCPResourceTemplate.
+
+
+#### `from_mcp_template`
+
+```python
+from_mcp_template(cls, mcp_template: MCPResourceTemplate) -> ResourceTemplate
+```
+
+Creates a FastMCP ResourceTemplate from a raw MCP ResourceTemplate object.
+
+
+#### `key`
+
+```python
+key(self) -> str
+```
+
+The key of the component. This is used for internal bookkeeping
+and may reflect e.g. prefixes or other identifiers. You should not depend on
+keys having a certain value, as the same tool loaded from different
+hierarchies of servers may have different keys.
+
+
+### `FunctionResourceTemplate`
+
+
+A template for dynamically creating resources.
+
+
+**Methods:**
+
+#### `from_function`
+
+```python
+from_function(cls, fn: Callable[..., Any], uri_template: str, name: str | None = None, description: str | None = None, mime_type: str | None = None, tags: set[str] | None = None, enabled: bool | None = None) -> FunctionResourceTemplate
+```
+
+Create a template from a function.
+

docs/python-sdk/fastmcp-resources-types.mdx

@@ -0,0 +1,83 @@
+---
+title: types
+sidebarTitle: types
+---
+
+# `fastmcp.resources.types`
+
+
+Concrete resource implementations.
+
+## Classes
+
+### `TextResource`
+
+
+A resource that reads from a string.
+
+
+### `BinaryResource`
+
+
+A resource that reads from bytes.
+
+
+### `FileResource`
+
+
+A resource that reads from a file.
+
+Set is_binary=True to read file as binary data instead of text.
+
+
+**Methods:**
+
+#### `validate_absolute_path`
+
+```python
+validate_absolute_path(cls, path: Path) -> Path
+```
+
+Ensure path is absolute.
+
+
+#### `set_binary_from_mime_type`
+
+```python
+set_binary_from_mime_type(cls, is_binary: bool, info: ValidationInfo) -> bool
+```
+
+Set is_binary based on mime_type if not explicitly set.
+
+
+### `HttpResource`
+
+
+A resource that reads from an HTTP endpoint.
+
+
+### `DirectoryResource`
+
+
+A resource that lists files in a directory.
+
+
+**Methods:**
+
+#### `validate_absolute_path`
+
+```python
+validate_absolute_path(cls, path: Path) -> Path
+```
+
+Ensure path is absolute.
+
+
+#### `list_files`
+
+```python
+list_files(self) -> list[Path]
+```
+
+List files in the directory.
+

docs/python-sdk/fastmcp-server-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.server`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-server-auth-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.server.auth`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-server-auth-auth.mdx

@@ -0,0 +1,10 @@
+---
+title: auth
+sidebarTitle: auth
+---
+
+# `fastmcp.server.auth.auth`
+
+## Classes
+
+### `OAuthProvider`

docs/python-sdk/fastmcp-server-auth-providers-__init__.mdx

@@ -0,0 +1,8 @@
+---
+title: __init__
+sidebarTitle: __init__
+---
+
+# `fastmcp.server.auth.providers`
+
+*This module is empty or contains only private/internal implementations.*

docs/python-sdk/fastmcp-server-auth-providers-bearer.mdx

@@ -0,0 +1,69 @@
+---
+title: bearer
+sidebarTitle: bearer
+---
+
+# `fastmcp.server.auth.providers.bearer`
+
+## Classes
+
+### `JWKData`
+
+
+JSON Web Key data structure.
+
+
+### `JWKSData`
+
+
+JSON Web Key Set data structure.
+
+
+### `RSAKeyPair`
+
+**Methods:**
+
+#### `generate`
+
+```python
+generate(cls) -> 'RSAKeyPair'
+```
+
+Generate an RSA key pair for testing.
+
+**Returns:**
+- (private_key_pem, public_key_pem)
+
+
+#### `create_token`
+
+```python
+create_token(self, subject: str = 'fastmcp-user', issuer: str = 'https://fastmcp.example.com', audience: str | list[str] | None = None, scopes: list[str] | None = None, expires_in_seconds: int = 3600, additional_claims: dict[str, Any] | None = None, kid: str | None = None) -> str
+```
+
+Generate a test JWT token for testing purposes.
+
+**Args:**
+- `private_key_pem`: RSA private key in PEM format
+- `subject`: Subject claim (usually user ID)
+- `issuer`: Issuer claim
+- `audience`: Audience claim - can be a string or list of strings (optional)
+- `scopes`: List of scopes to include
+- `expires_in_seconds`: Token expiration time in seconds
+- `additional_claims`: Any additional claims to include
+- `kid`: Key ID for JWKS lookup (optional)
+
+**Returns:**
+- Signed JWT token string
+
+
+### `BearerAuthProvider`
+
+
+Simple JWT Bearer Token validator for hosted MCP servers.
+Uses RS256 asymmetric encryption. Supports either static public key
+or JWKS URI for key rotation.
+
+Note that this provider DOES NOT permit client registration or revocation, or any OAuth flows.
+It is intended to be used with a control plane that manages clients and tokens.
+