fastmcp 2.5.2__tar.gz → 2.6.1__tar.gz

{fastmcp-2.5.2 → fastmcp-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.5.2
+Version: 2.6.1
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -17,9 +17,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: authlib>=1.5.2
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: mcp<2.0.0,>=1.9.0
+Requires-Dist: mcp<2.0.0,>=1.9.2
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
@@ -41,14 +42,14 @@ Description-Content-Type: text/markdown
 <a href="https://trendshift.io/repositories/13266" target="_blank"><img src="https://trendshift.io/api/badge/repositories/13266" alt="jlowin%2Ffastmcp | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 </div>
 
-> [!NOTE]
-> #### FastMCP 2.0 & The Official MCP SDK
+> [!Note]
+> #### Beyond the Protocol
+> 
+> FastMCP is the standard framework for working with the Model Context Protocol. FastMCP 1.0 was incorporated into the [official low-level Python SDK](https://github.com/modelcontextprotocol/python-sdk), and FastMCP 2.0 *(this project)* provides a complete toolkit for working with the MCP ecosystem.
 >
-> FastMCP is the standard framework for building MCP servers and clients. FastMCP 1.0 was incorporated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
+> FastMCP has a comprehensive set of features that go far beyond the core MCP specification, all in service of providing **the simplest path to production**. These include client support, server composition, auth, automatic generation from OpenAPI specs, remote server proxying, built-in testing tools, integrations, and more.
 >
-> **This is FastMCP 2.0,** the actively maintained version that significantly expands on 1.0's basic server-building capabilities by introducing full client support, server composition, OpenAPI/FastAPI integration, remote server proxying, built-in testing tools, and more.
->
-> FastMCP 2.0 is the complete toolkit for modern AI applications. Ready to upgrade or get started? Follow the [installation instructions](https://gofastmcp.com/getting-started/installation), which include specific steps for upgrading from the official MCP SDK.
+> Ready to upgrade or get started? Follow the [installation instructions](/getting-started/installation), which include specific steps for upgrading from the official MCP SDK.
 
 ---
 
@@ -103,6 +104,7 @@ There are two ways to access the LLM-friendly documentation:
   - [Proxy Servers](#proxy-servers)
   - [Composing MCP Servers](#composing-mcp-servers)
   - [OpenAPI \& FastAPI Generation](#openapi--fastapi-generation)
+  - [Authentication \& Security](#authentication--security)
 - [Running Your Server](#running-your-server)
 - [Contributing](#contributing)
   - [Prerequisites](#prerequisites)
@@ -115,20 +117,20 @@ There are two ways to access the LLM-friendly documentation:
 
 ## What is MCP?
 
-The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. It is often described as "the USB-C port for AI", providing a uniform way to connect LLMs to resources they can use. It may be easier to think of it as an API, but specifically designed for LLM interactions. MCP servers can:
 
-- Expose data through **Resources** (similar to `GET` requests; load info into context)
-- Provide functionality through **Tools** (similar to `POST`/`PUT` requests; execute actions)
-- Define interaction patterns through **Prompts** (reusable templates)
+- Expose data through **Resources** (think of these sort of like GET endpoints; they are used to load information into the LLM's context)
+- Provide functionality through **Tools** (sort of like POST endpoints; they are used to execute code or otherwise produce a side effect)
+- Define interaction patterns through **Prompts** (reusable templates for LLM interactions)
 - And more!
 
-FastMCP provides a high-level, Pythonic interface for building and interacting with these servers.
+FastMCP provides a high-level, Pythonic interface for building, managing, and interacting with these servers.
 
 ## Why FastMCP?
 
 The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
 
-While the core server concepts of FastMCP 1.0 laid the groundwork and were contributed to the official MCP SDK, **FastMCP 2.0 (this project) is the actively developed successor**, adding significant enhancements and entirely new capabilities like a powerful **client library**, server **proxying**, **composition** patterns, **OpenAPI/FastAPI integration**, and much more.
+FastMCP 2.0 has evolved into a comprehensive platform that goes far beyond basic protocol implementation. While 1.0 provided server-building capabilities (and is now part of the official MCP SDK), 2.0 offers a complete ecosystem including client libraries, authentication systems, deployment tools, integrations with major AI platforms, testing frameworks, and production-ready infrastructure patterns.
 
 FastMCP aims to be:
 
@@ -138,7 +140,7 @@ FastMCP aims to be:
 
 🐍 **Pythonic:** Feels natural to Python developers
 
-🔍 **Complete:** FastMCP aims to provide a full implementation of the core MCP specification for both servers and clients
+🔍 **Complete:** A comprehensive platform for all MCP use cases, from dev to prod
 
 ## Installation
 
@@ -156,7 +158,7 @@ These are the building blocks for creating MCP servers and clients with FastMCP.
 
 ### The `FastMCP` Server
 
-The central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like [authentication providers](https://gofastmcp.com/servers/fastmcp#authentication).
+The central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like authentication.
 
 ```python
 from fastmcp import FastMCP
@@ -329,6 +331,16 @@ Automatically generate FastMCP servers from existing OpenAPI specifications (`Fa
 
 Learn more: [**OpenAPI Integration**](https://gofastmcp.com/patterns/openapi) | [**FastAPI Integration**](https://gofastmcp.com/patterns/fastapi).
 
+### Authentication & Security
+
+FastMCP provides built-in authentication support to secure both your MCP servers and clients in production environments. Protect your server endpoints from unauthorized access and authenticate your clients against secured MCP servers using industry-standard protocols.
+
+- **Server Protection**: Secure your FastMCP server endpoints with configurable authentication providers
+- **Client Authentication**: Connect to authenticated MCP servers with automatic credential management
+- **Production Ready**: Support for common authentication patterns used in enterprise environments
+
+Learn more in the **Authentication Documentation** for [servers](https://gofastmcp.com/servers/auth) and [clients](https://gofastmcp.com/clients/auth).
+
 ## Running Your Server
 
 The main way to run a FastMCP server is by calling the `run()` method on your server instance:

{fastmcp-2.5.2 → fastmcp-2.6.1}/README.md

@@ -12,14 +12,14 @@
 <a href="https://trendshift.io/repositories/13266" target="_blank"><img src="https://trendshift.io/api/badge/repositories/13266" alt="jlowin%2Ffastmcp | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 </div>
 
-> [!NOTE]
-> #### FastMCP 2.0 & The Official MCP SDK
+> [!Note]
+> #### Beyond the Protocol
+> 
+> FastMCP is the standard framework for working with the Model Context Protocol. FastMCP 1.0 was incorporated into the [official low-level Python SDK](https://github.com/modelcontextprotocol/python-sdk), and FastMCP 2.0 *(this project)* provides a complete toolkit for working with the MCP ecosystem.
 >
-> FastMCP is the standard framework for building MCP servers and clients. FastMCP 1.0 was incorporated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
+> FastMCP has a comprehensive set of features that go far beyond the core MCP specification, all in service of providing **the simplest path to production**. These include client support, server composition, auth, automatic generation from OpenAPI specs, remote server proxying, built-in testing tools, integrations, and more.
 >
-> **This is FastMCP 2.0,** the actively maintained version that significantly expands on 1.0's basic server-building capabilities by introducing full client support, server composition, OpenAPI/FastAPI integration, remote server proxying, built-in testing tools, and more.
->
-> FastMCP 2.0 is the complete toolkit for modern AI applications. Ready to upgrade or get started? Follow the [installation instructions](https://gofastmcp.com/getting-started/installation), which include specific steps for upgrading from the official MCP SDK.
+> Ready to upgrade or get started? Follow the [installation instructions](/getting-started/installation), which include specific steps for upgrading from the official MCP SDK.
 
 ---
 
@@ -74,6 +74,7 @@ There are two ways to access the LLM-friendly documentation:
   - [Proxy Servers](#proxy-servers)
   - [Composing MCP Servers](#composing-mcp-servers)
   - [OpenAPI \& FastAPI Generation](#openapi--fastapi-generation)
+  - [Authentication \& Security](#authentication--security)
 - [Running Your Server](#running-your-server)
 - [Contributing](#contributing)
   - [Prerequisites](#prerequisites)
@@ -86,20 +87,20 @@ There are two ways to access the LLM-friendly documentation:
 
 ## What is MCP?
 
-The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. It is often described as "the USB-C port for AI", providing a uniform way to connect LLMs to resources they can use. It may be easier to think of it as an API, but specifically designed for LLM interactions. MCP servers can:
 
-- Expose data through **Resources** (similar to `GET` requests; load info into context)
-- Provide functionality through **Tools** (similar to `POST`/`PUT` requests; execute actions)
-- Define interaction patterns through **Prompts** (reusable templates)
+- Expose data through **Resources** (think of these sort of like GET endpoints; they are used to load information into the LLM's context)
+- Provide functionality through **Tools** (sort of like POST endpoints; they are used to execute code or otherwise produce a side effect)
+- Define interaction patterns through **Prompts** (reusable templates for LLM interactions)
 - And more!
 
-FastMCP provides a high-level, Pythonic interface for building and interacting with these servers.
+FastMCP provides a high-level, Pythonic interface for building, managing, and interacting with these servers.
 
 ## Why FastMCP?
 
 The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
 
-While the core server concepts of FastMCP 1.0 laid the groundwork and were contributed to the official MCP SDK, **FastMCP 2.0 (this project) is the actively developed successor**, adding significant enhancements and entirely new capabilities like a powerful **client library**, server **proxying**, **composition** patterns, **OpenAPI/FastAPI integration**, and much more.
+FastMCP 2.0 has evolved into a comprehensive platform that goes far beyond basic protocol implementation. While 1.0 provided server-building capabilities (and is now part of the official MCP SDK), 2.0 offers a complete ecosystem including client libraries, authentication systems, deployment tools, integrations with major AI platforms, testing frameworks, and production-ready infrastructure patterns.
 
 FastMCP aims to be:
 
@@ -109,7 +110,7 @@ FastMCP aims to be:
 
 🐍 **Pythonic:** Feels natural to Python developers
 
-🔍 **Complete:** FastMCP aims to provide a full implementation of the core MCP specification for both servers and clients
+🔍 **Complete:** A comprehensive platform for all MCP use cases, from dev to prod
 
 ## Installation
 
@@ -127,7 +128,7 @@ These are the building blocks for creating MCP servers and clients with FastMCP.
 
 ### The `FastMCP` Server
 
-The central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like [authentication providers](https://gofastmcp.com/servers/fastmcp#authentication).
+The central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like authentication.
 
 ```python
 from fastmcp import FastMCP
@@ -300,6 +301,16 @@ Automatically generate FastMCP servers from existing OpenAPI specifications (`Fa
 
 Learn more: [**OpenAPI Integration**](https://gofastmcp.com/patterns/openapi) | [**FastAPI Integration**](https://gofastmcp.com/patterns/fastapi).
 
+### Authentication & Security
+
+FastMCP provides built-in authentication support to secure both your MCP servers and clients in production environments. Protect your server endpoints from unauthorized access and authenticate your clients against secured MCP servers using industry-standard protocols.
+
+- **Server Protection**: Secure your FastMCP server endpoints with configurable authentication providers
+- **Client Authentication**: Connect to authenticated MCP servers with automatic credential management
+- **Production Ready**: Support for common authentication patterns used in enterprise environments
+
+Learn more in the **Authentication Documentation** for [servers](https://gofastmcp.com/servers/auth) and [clients](https://gofastmcp.com/clients/auth).
+
 ## Running Your Server
 
 The main way to run a FastMCP server is by calling the `run()` method on your server instance:

fastmcp-2.6.1/docs/clients/auth/bearer.mdx

@@ -0,0 +1,85 @@
+---
+title: Bearer Token Authentication
+sidebarTitle: Bearer Auth
+description: Authenticate your FastMCP client with a Bearer token.
+icon: key
+---
+
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
+<VersionBadge version="2.6.0" />
+
+<Tip>
+Bearer Token authentication is only relevant for HTTP-based transports.
+</Tip>
+
+You can configure your FastMCP client to use **bearer authentication** by supplying a valid access token. This is most appropriate for service accounts, long-lived API keys, CI/CD, applications where authentication is managed separately, or other non-interactive authentication methods.
+
+A Bearer token is a JSON Web Token (JWT) that is used to authenticate a request. It is most commonly used in the `Authorization` header of an HTTP request, using the `Bearer` scheme:
+
+```http
+Authorization: Bearer <token>
+```
+
+
+## Client Usage
+
+The most straightforward way to use a pre-existing Bearer token is to provide it as a string to the `auth` parameter of the `fastmcp.Client` or transport instance. FastMCP will automatically format it correctly for the `Authorization` header and bearer scheme.
+
+<Tip>
+If you're using a string token, do not include the `Bearer` prefix. FastMCP will add it for you.
+</Tip>
+
+```python {5}
+from fastmcp import Client
+
+async with Client(
+    "https://fastmcp.cloud/mcp", 
+    auth="<your-token>",
+) as client:
+    await client.ping()
+```
+
+You can also supply a Bearer token to a transport instance, such as `StreamableHttpTransport` or `SSETransport`:
+
+```python {6}
+from fastmcp import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+transport = StreamableHttpTransport(
+    "http://fastmcp.cloud/mcp", 
+    auth="<your-token>",
+)
+
+async with Client(transport) as client:
+    await client.ping()
+```
+
+## `BearerAuth` Helper
+
+If you prefer to be more explicit and not rely on FastMCP to transform your string token, you can use the `BearerAuth` class yourself, which implements the `httpx.Auth` interface.
+
+```python {6}
+from fastmcp import Client
+from fastmcp.client.auth import BearerAuth
+
+async with Client(
+    "https://fastmcp.cloud/mcp", 
+    auth=BearerAuth(token="<your-token>"),
+) as client:
+    await client.ping()
+```
+
+## Custom Headers
+
+If the MCP server expects a custom header or token scheme, you can manually set the client's `headers` instead of using the `auth` parameter:
+
+```python {5}
+from fastmcp import Client
+
+async with Client(
+    "https://fastmcp.cloud/mcp", 
+    headers={"X-API-Key": "<your-token>"},
+) as client:
+    await client.ping()
+```

fastmcp-2.6.1/docs/clients/auth/oauth.mdx

@@ -0,0 +1,116 @@
+---
+title: OAuth Authentication
+sidebarTitle: OAuth
+description: Authenticate your FastMCP client via OAuth 2.1.
+icon: window
+---
+
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
+<VersionBadge version="2.6.0" />
+
+<Tip>
+OAuth authentication is only relevant for HTTP-based transports and requires user interaction via a web browser.
+</Tip>
+
+When your FastMCP client needs to access an MCP server protected by OAuth 2.1, and the process requires user interaction (like logging in and granting consent), you should use the Authorization Code Flow. FastMCP provides the `fastmcp.client.auth.OAuth` helper to simplify this entire process.
+
+This flow is common for user-facing applications where the application acts on behalf of the user.
+
+## Client Usage
+
+
+### Default Configuration
+
+The simplest way to use OAuth is to pass the string `"oauth"` to the `auth` parameter of the `Client` or transport instance. FastMCP will automatically configure the client to use OAuth with default settings:
+
+```python {4}
+from fastmcp import Client
+
+# Uses default OAuth settings
+async with Client("https://fastmcp.cloud/mcp", auth="oauth") as client:
+    await client.ping()
+```
+
+
+### `OAuth` Helper
+
+To fully configure the OAuth flow, use the `OAuth` helper and pass it to the `auth` parameter of the `Client` or transport instance. `OAuth` manages the complexities of the OAuth 2.1 Authorization Code Grant with PKCE (Proof Key for Code Exchange) for enhanced security, and implements the full `httpx.Auth` interface.
+
+```python {2, 4, 6}
+from fastmcp import Client
+from fastmcp.client.auth import OAuth
+
+oauth = OAuth(mcp_url="https://fastmcp.cloud/mcp")
+
+async with Client("https://fastmcp.cloud/mcp", auth=oauth) as client:
+    await client.ping()
+```
+
+#### `OAuth` Parameters
+
+- **`mcp_url`** (`str`): The full URL of the target MCP server endpoint. Used to discover OAuth server metadata
+- **`scopes`** (`str | list[str]`, optional): OAuth scopes to request. Can be space-separated string or list of strings
+- **`client_name`** (`str`, optional): Client name for dynamic registration. Defaults to `"FastMCP Client"`
+- **`token_storage_cache_dir`** (`Path`, optional): Token cache directory. Defaults to `~/.fastmcp/oauth-mcp-client-cache/`
+- **`additional_client_metadata`** (`dict[str, Any]`, optional): Extra metadata for client registration
+
+
+## OAuth Flow
+
+The OAuth flow is triggered when you use a FastMCP `Client` configured to use OAuth.
+
+<Steps>
+<Step title="Token Check">
+The client first checks the `token_storage_cache_dir` for existing, valid tokens for the target server. If one is found, it will be used to authenticate the client.
+</Step>
+<Step title="OAuth Server Discovery">
+If no valid tokens exist, the client attempts to discover the OAuth server's endpoints using a well-known URI (e.g., `/.well-known/oauth-authorization-server`) based on the `mcp_url`.
+</Step>
+<Step title="Dynamic Client Registration">
+If the OAuth server supports it and the client isn't already registered (or credentials aren't cached), the client performs dynamic client registration according to RFC 7591.
+</Step>
+<Step title="Local Callback Server">
+A temporary local HTTP server is started on an available port. This server's address (e.g., `http://127.0.0.1:<port>/callback`) acts as the `redirect_uri` for the OAuth flow.
+</Step>
+<Step title="Browser Interaction">
+The user's default web browser is automatically opened, directing them to the OAuth server's authorization endpoint. The user logs in and grants (or denies) the requested `scopes`.
+</Step>
+<Step title="Authorization Code & Token Exchange">
+Upon approval, the OAuth server redirects the user's browser to the local callback server with an `authorization_code`. The client captures this code and exchanges it with the OAuth server's token endpoint for an `access_token` (and often a `refresh_token`) using PKCE for security.
+</Step>
+<Step title="Token Caching">
+The obtained tokens are saved to the `token_storage_cache_dir` for future use, eliminating the need for repeated browser interactions.
+</Step> 
+<Step title="Authenticated Requests">
+The access token is automatically included in the `Authorization` header for requests to the MCP server. 
+</Step>
+<Step title="Refresh Token">
+If the access token expires, the client will automatically use the refresh token to get a new access token.
+</Step>
+</Steps>
+
+## Token Management
+
+### Token Storage
+
+OAuth access tokens are automatically cached in `~/.fastmcp/oauth-mcp-client-cache/` and persist between application runs. Files are keyed by the OAuth server's base URL.
+
+### Managing Cache
+
+To clear the tokens for a specific server, instantiate a `FileTokenStorage` instance and call the `clear` method:
+
+```python
+from fastmcp.client.auth import FileTokenStorage
+
+storage = FileTokenStorage(server_url="https://fastmcp.cloud/mcp")
+await storage.clear()
+```
+
+To clear *all* tokens for all servers, call the `clear_all` method on the `FileTokenStorage` class:
+
+```python
+from fastmcp.client.auth import FileTokenStorage
+
+FileTokenStorage.clear_all()
+```

{fastmcp-2.5.2 → fastmcp-2.6.1}/docs/clients/client.mdx

@@ -345,7 +345,7 @@ For consistent behavior across all transports, we recommend explicitly setting t
 
 #### Error Handling
 
-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.client.ClientError`.
+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`.
 
 ```python
 async def safe_call_tool():

{fastmcp-2.5.2 → fastmcp-2.6.1}/docs/deployment/running-server.mdx

@@ -59,7 +59,7 @@ For development and testing, you can use the `dev` command to run your server wi
 fastmcp dev server.py
 ```
 
-See the [CLI documentation](/deployment/cli) for detailed information about all available commands and options.
+See the [CLI documentation](/patterns/cli) for detailed information about all available commands and options.
 
 ## Transport Options
 
@@ -270,4 +270,4 @@ async def health_check(request: Request) -> PlainTextResponse:
 
 if __name__ == "__main__":
     mcp.run()
-```
+```

{fastmcp-2.5.2 → fastmcp-2.6.1}/docs/docs.json

@@ -1,5 +1,9 @@
 {
     "$schema": "https://mintlify.com/docs.json",
+    "appearance": {
+        "default": "system",
+        "strict": false
+    },
     "background": {
         "color": {
             "dark": "#222831",
@@ -13,6 +17,10 @@
         "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",
@@ -46,22 +54,34 @@
                 "group": "Servers",
                 "pages": [
                     "servers/fastmcp",
-                    "servers/tools",
-                    "servers/resources",
-                    "servers/prompts",
-                    "servers/context",
+                    {
+                        "group": "Core Components",
+                        "icon": "toolbox",
+                        "pages": [
+                            "servers/tools",
+                            "servers/resources",
+                            "servers/prompts",
+                            "servers/context"
+                        ]
+                    },
+                    {
+                        "group": "Authentication",
+                        "icon": "shield-check",
+                        "pages": [
+                            "servers/auth/bearer"
+                        ]
+                    },
                     "servers/openapi",
                     "servers/proxy",
-                    "servers/composition"
-                ]
-            },
-            {
-                "group": "Deployment",
-                "pages": [
-                    "deployment/running-server",
-                    "deployment/asgi",
-                    "deployment/authentication",
-                    "deployment/cli"
+                    "servers/composition",
+                    {
+                        "group": "Deployment",
+                        "icon": "upload",
+                        "pages": [
+                            "deployment/running-server",
+                            "deployment/asgi"
+                        ]
+                    }
                 ]
             },
             {
@@ -69,21 +89,35 @@
                 "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/decorating-methods",
                     "patterns/http-requests",
-                    "patterns/contrib",
-                    "patterns/testing"
+                    "patterns/testing",
+                    "patterns/cli"
                 ]
-            },
-            {
-                "group": "Deployment",
-                "pages": []
             }
         ]
     },
@@ -97,5 +131,8 @@
             "source": "/patterns/composition"
         }
     ],
+    "search": {
+        "prompt": "Search the docs..."
+    },
     "theme": "mint"
 }

{fastmcp-2.5.2 → fastmcp-2.6.1}/docs/getting-started/welcome.mdx

@@ -9,7 +9,7 @@ icon: hand-wave
 
 The [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) is a new, standardized way to provide context and tools to your LLMs, and FastMCP makes building MCP servers and clients simple and intuitive. Create tools, expose resources, define prompts, and more with clean, Pythonic code:
 
-```python {1, 3, 5, 11}
+```python {1}
 from fastmcp import FastMCP
 
 mcp = FastMCP("Demo 🚀")
@@ -24,16 +24,17 @@ if __name__ == "__main__":
 ```
 
 
-## FastMCP and the Official MCP SDK
+## Beyond the Protocol
 
-FastMCP is the standard framework for building MCP servers and clients. FastMCP 1.0 was incorporated into the [official MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
+FastMCP is the standard framework for working with the Model Context Protocol. FastMCP 1.0 was incorporated into the [official low-level Python SDK](https://github.com/modelcontextprotocol/python-sdk), and FastMCP 2.0 *(this project)* provides a complete toolkit for working with the MCP ecosystem.
 
-**This is FastMCP 2.0,** the [actively maintained version](https://github.com/jlowin/fastmcp) that significantly expands on 1.0's basic server-building capabilities by introducing full client support, server composition, OpenAPI/FastAPI integration, remote server proxying, built-in testing tools, and more.
+FastMCP has a comprehensive set of features that go far beyond the core MCP specification, all in service of providing **the simplest path to production**. These include client support, server composition, auth, automatic generation from OpenAPI specs, remote server proxying, built-in testing tools, integrations, and more.
 
-FastMCP 2.0 is the complete toolkit for modern AI applications. Ready to upgrade or get started? Follow the [installation instructions](/getting-started/installation), which include specific steps for upgrading from the official MCP SDK.
+Ready to upgrade or get started? Follow the [installation instructions](/getting-started/installation), which include specific steps for upgrading from the official MCP SDK.
 
 
 ## What is MCP?
+
 The Model Context Protocol lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. It is often described as "the USB-C port for AI", providing a uniform way to connect LLMs to resources they can use. It may be easier to think of it as an API, but specifically designed for LLM interactions. MCP servers can:
 
 - Expose data through `Resources` (think of these sort of like GET endpoints; they are used to load information into the LLM's context)
@@ -41,14 +42,13 @@ The Model Context Protocol lets you build servers that expose data and functiona
 - Define interaction patterns through `Prompts` (reusable templates for LLM interactions)
 - And more!
 
-There is a low-level Python SDK available for implementing the protocol directly, but FastMCP aims to make that easier by providing a high-level, Pythonic interface.
-
+FastMCP provides a high-level, Pythonic interface for building, managing, and interacting with these servers.
 
 ## Why FastMCP?
 
 The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
 
-While the core server concepts of FastMCP 1.0 laid the groundwork and were contributed to the official MCP SDK, FastMCP 2.0 (this project) is the actively developed successor, adding significant enhancements and entirely new capabilities like a powerful client library, server proxying, composition patterns, and much more.
+FastMCP 2.0 has evolved into a comprehensive platform that goes far beyond basic protocol implementation. While 1.0 provided server-building capabilities (and is now part of the official MCP SDK), 2.0 offers a complete ecosystem including client libraries, authentication systems, deployment tools, integrations with major AI platforms, testing frameworks, and production-ready infrastructure patterns.
 
 FastMCP aims to be:
 
@@ -58,7 +58,7 @@ FastMCP aims to be:
 
 🐍 **Pythonic**: Feels natural to Python developers
 
-🔍 **Complete**: FastMCP aims to provide a full implementation of the core MCP specification
+🔍 **Complete**: A comprehensive platform for all MCP use cases, from dev to prod
 
 
 ## `llms.txt`