fastmcp 2.6.0__tar.gz → 2.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.6.0
+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
@@ -104,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)
@@ -116,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:
 
@@ -139,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
 
@@ -157,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
@@ -330,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.6.0 → fastmcp-2.6.1}/README.md

@@ -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.0 → fastmcp-2.6.1}/docs/clients/auth/bearer.mdx

@@ -1,7 +1,7 @@
 ---
 title: Bearer Token Authentication
 sidebarTitle: Bearer Auth
-description: Authenticate your FastMCP client using pre-existing OAuth 2.0 Bearer tokens.
+description: Authenticate your FastMCP client with a Bearer token.
 icon: key
 ---
 

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/clients/auth/oauth.mdx

@@ -1,7 +1,7 @@
 ---
 title: OAuth Authentication
 sidebarTitle: OAuth
-description: Authenticate your FastMCP client with servers using the OAuth 2.0 Authorization Code Grant, including user interaction via a web browser.
+description: Authenticate your FastMCP client via OAuth 2.1.
 icon: window
 ---
 
@@ -13,7 +13,7 @@ import { VersionBadge } from "/snippets/version-badge.mdx"
 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.0, 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.
+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.
 
@@ -35,7 +35,7 @@ async with Client("https://fastmcp.cloud/mcp", auth="oauth") as client:
 
 ### `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.0 Authorization Code Grant with PKCE (Proof Key for Code Exchange) for enhanced security, and implements the full `httpx.Auth` interface.
+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

{fastmcp-2.6.0 → 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.6.0 → fastmcp-2.6.1}/docs/docs.json

@@ -93,8 +93,8 @@
                         "group": "Authentication",
                         "icon": "user-shield",
                         "pages": [
-                            "clients/auth/bearer",
-                            "clients/auth/oauth"
+                            "clients/auth/oauth",
+                            "clients/auth/bearer"
                         ]
                     },
                     "clients/advanced-features"
@@ -106,6 +106,7 @@
                     "integrations/anthropic",
                     "integrations/claude-desktop",
                     "integrations/openai",
+                    "integrations/gemini",
                     "integrations/contrib"
                 ]
             },

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

@@ -42,8 +42,7 @@ 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?
 

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/integrations/anthropic.mdx

@@ -1,7 +1,7 @@
 ---
 title: Anthropic
 sidebarTitle: Anthropic
-description: Access FastMCP servers from the Anthropic Messages API
+description: Call FastMCP servers from the Anthropic API
 icon: message-smile
 ---
 
@@ -66,6 +66,12 @@ To use the Messages API with MCP servers, you'll need to install the Anthropic P
 pip install anthropic
 ```
 
+You'll also need to authenticate with Anthropic. You can do this by setting the `ANTHROPIC_API_KEY` environment variable. Consult the Anthropic SDK documentation for more information.
+
+```bash
+export ANTHROPIC_API_KEY="your-api-key"
+```
+
 Here is an example of how to call your server from Python. Note that you'll need to replace `https://your-server-url.com` with the actual URL of your server. In addition, we use `/sse` as the endpoint because we deployed an SSE server with the default path; you may need to use a different endpoint if you customized your server's deployment. **At this time you must also include the `extra_headers` parameter with the `anthropic-beta` header.**
 
 ```python {5, 13-22}

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/integrations/claude-desktop.mdx

@@ -1,7 +1,7 @@
 ---
 title: Claude Desktop
 sidebarTitle: Claude Desktop
-description: Integrate FastMCP servers with Claude Desktop
+description: Call FastMCP servers from Claude Desktop
 icon: desktop
 ---
 

fastmcp-2.6.1/docs/integrations/gemini.mdx

@@ -0,0 +1,108 @@
+---
+title: Gemini SDK
+sidebarTitle: Gemini SDK
+description: Call FastMCP servers from the Google Gemini SDK
+icon: message-smile
+---
+
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
+Google's Gemini API includes built-in support for MCP servers in their Python and JavaScript SDKs, allowing you to connect directly to MCP servers and use their tools seamlessly with Gemini models.
+
+## Gemini Python SDK
+
+Google's [Gemini Python SDK](https://ai.google.dev/gemini-api/docs) can use FastMCP clients directly.
+
+<Note>
+Google's MCP integration is currently experimental and available in the Python and JavaScript SDKs. The API automatically calls MCP tools when needed and can connect to both local and remote MCP servers.
+</Note>
+
+<Tip>
+Currently, Gemini's MCP support only accesses **tools** from MCP servers—it queries the `list_tools` endpoint and exposes those functions to the AI. Other MCP features like resources and prompts are not currently supported.
+</Tip>
+
+### Create a Server
+
+First, create a FastMCP server with the tools you want to expose. For this example, we'll create a server with a single tool that rolls dice.
+
+```python server.py
+import random
+from fastmcp import FastMCP
+
+mcp = FastMCP(name="Dice Roller")
+
+@mcp.tool()
+def roll_dice(n_dice: int) -> list[int]:
+    """Roll `n_dice` 6-sided dice and return the results."""
+    return [random.randint(1, 6) for _ in range(n_dice)]
+
+if __name__ == "__main__":
+    mcp.run()
+```
+
+### Call the Server
+
+
+To use the Gemini API with MCP, you'll need to install the Google Generative AI SDK:
+
+```bash
+pip install google-genai
+```
+
+You'll also need to authenticate with Google. You can do this by setting the `GEMINI_API_KEY` environment variable. Consult the Gemini SDK documentation for more information.
+
+```bash
+export GEMINI_API_KEY="your-api-key"
+```
+
+Gemini's SDK interacts directly with the MCP client session. To call the server, you'll need to instantiate a FastMCP client, enter its connection context, and pass the client session to the Gemini SDK.
+
+```python {5, 9, 15}
+from fastmcp import Client
+from google import genai
+import asyncio
+
+mcp_client = Client("server.py")
+gemini_client = genai.Client()
+
+async def main():    
+    async with client:
+        response = await gemini_client.aio.models.generate_content(
+            model="gemini-2.0-flash",
+            contents="Roll 3 dice!",
+            config=genai.types.GenerateContentConfig(
+                temperature=0,
+                tools=[mcp_client.session],  # Pass the FastMCP client session
+            ),
+        )
+        print(response.text)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+If you run this code, you'll see output like:
+
+```text
+Okay, I rolled 3 dice and got a 5, 4, and 1.
+```
+
+### Remote & Authenticated Servers
+
+In the above example, we connected to our local server using `stdio` transport. Because we're using a FastMCP client, you can also connect to any local or remote MCP server, using any [transport](/clients/transports) or [auth](/clients/auth) method supported by FastMCP, simply by changing the client configuration.
+
+For example, to connect to a remote, authenticated server, you can use the following client:
+
+```python
+from fastmcp import Client
+from fastmcp.client.auth import BearerAuth
+
+client = Client(
+    "https://my-server.com/sse",
+    auth=BearerAuth("<your-token>"),
+)
+```
+
+The rest of the code remains the same.
+
+

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/integrations/openai.mdx

@@ -1,7 +1,7 @@
 ---
 title: OpenAI
 sidebarTitle: OpenAI
-description: Access FastMCP servers from the OpenAI API
+description: Call FastMCP servers from the OpenAI API
 icon: message-smile
 ---
 
@@ -9,7 +9,7 @@ import { VersionBadge } from "/snippets/version-badge.mdx"
 
 OpenAI recently announced support for MCP servers in the Responses API. Note that at this time, MCP is not supported in ChatGPT.
 
-## MCP in the Responses API
+## Responses API
 
 OpenAI's [Responses API](https://platform.openai.com/docs/api-reference/responses) supports [MCP servers](https://platform.openai.com/docs/guides/tools-remote-mcp) as remote tool sources, allowing you to extend AI capabilities with custom functions.
 
@@ -71,6 +71,12 @@ To use the Responses API, you'll need to install the OpenAI Python SDK (not incl
 pip install openai
 ```
 
+You'll also need to authenticate with OpenAI. You can do this by setting the `OPENAI_API_KEY` environment variable. Consult the OpenAI SDK documentation for more information.
+
+```bash
+export OPENAI_API_KEY="your-api-key"
+```
+
 Here is an example of how to call your server from Python. Note that you'll need to replace `https://your-server-url.com` with the actual URL of your server. In addition, we use `/sse` as the endpoint because we deployed an SSE server with the default path; you may need to use a different endpoint if you customized your server's deployment.
 
 ```python {4, 11-16}

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/servers/auth/bearer.mdx

@@ -12,6 +12,10 @@ import { VersionBadge } from "/snippets/version-badge.mdx"
 Authentication and authorization are only relevant for HTTP-based transports.
 </Tip>
 
+<Note>
+The [MCP specification](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) requires servers to implement full OAuth 2.1 authorization flows with dynamic client registration, server metadata discovery, and complete token endpoints. FastMCP's Bearer Token authentication provides a simpler, more practical alternative by directly validating pre-issued JWT tokens—ideal for service-to-service communication and programmatic environments where full OAuth flows may be impractical, and in accordance with how the MCP ecosystem is pragmatically evolving. However, please note that since it doesn't implement the full OAuth 2.1 flow, this implementation does not strictly comply with the MCP specification.
+</Note>
+
 Bearer Token authentication is a common way to secure HTTP-based APIs. In this model, the client sends a token (usually a JSON Web Token or JWT) in the `Authorization` header with the "Bearer" scheme. The server then validates this token to grant or deny access.
 
 FastMCP supports Bearer Token authentication for its HTTP-based transports (`streamable-http` and `sse`), allowing you to protect your server from unauthorized access.
@@ -32,7 +36,7 @@ This design allows you to integrate FastMCP servers into existing authentication
 To enable Bearer Token validation on your FastMCP server, use the `BearerAuthProvider` class. This provider validates incoming JWTs by verifying signatures, checking expiration, and optionally validating claims.
 
 <Warning>
-The `BearerAuthProvider` validates tokens; it does **not** issue them (or implement any part of an OAuth flow). You'll need to generate tokens separately, either using FastMCP utilities or an external Identity Provider (IdP) or OAuth 2.0 Authorization Server.
+The `BearerAuthProvider` validates tokens; it does **not** issue them (or implement any part of an OAuth flow). You'll need to generate tokens separately, either using FastMCP utilities or an external Identity Provider (IdP) or OAuth 2.1 Authorization Server.
 </Warning>
 
 ### Basic Setup
@@ -100,7 +104,7 @@ JWKS is recommended for production as it supports automatic key rotation and mul
 For development and testing, FastMCP provides the `RSAKeyPair` utility class to generate tokens without needing an external OAuth provider.
 
 <Warning>
-The `RSAKeyPair` utility is intended for development and testing only. For production, use a proper OAuth 2.0 Authorization Server or Identity Provider.
+The `RSAKeyPair` utility is intended for development and testing only. For production, use a proper OAuth 2.1 Authorization Server or Identity Provider.
 </Warning>
 ### Basic Token Generation
 

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/servers/composition.mdx

@@ -33,7 +33,7 @@ The choice of importing or mounting depends on your use case and requirements.
 
 ### Proxy Servers
 
-FastMCP supports [MCP proxying](/patterns/proxy), which allows you to mirror a local or remote server in a local FastMCP instance. Proxies are fully compatible with both importing and mounting.
+FastMCP supports [MCP proxying](/servers/proxy), which allows you to mirror a local or remote server in a local FastMCP instance. Proxies are fully compatible with both importing and mounting.
 
 <VersionBadge version="2.4.0" />
 

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/servers/fastmcp.mdx

@@ -25,7 +25,7 @@ mcp_with_instructions = FastMCP(
     instructions="""
         This server provides data analysis tools.
         Call get_average() to analyze numerical data.
-        """
+    """,
 )
 ```
 
@@ -135,7 +135,7 @@ For detailed information on each transport, how to configure them (host, port, p
 
 FastMCP supports composing multiple servers together using `import_server` (static copy) and `mount` (live link). This allows you to organize large applications into modular components or reuse existing servers.
 
-See the [Server Composition](/patterns/composition) guide for full details, best practices, and examples.
+See the [Server Composition](/servers/composition) guide for full details, best practices, and examples.
 
 ```python
 # Example: Importing a subserver
@@ -159,7 +159,7 @@ main.mount("sub", sub)
 
 FastMCP can act as a proxy for any MCP server (local or remote) using `FastMCP.as_proxy`, letting you bridge transports or add a frontend to existing servers. For example, you can expose a remote SSE server locally via stdio, or vice versa.
 
-See the [Proxying Servers](/patterns/proxy) guide for details and advanced usage.
+See the [Proxying Servers](/servers/proxy) guide for details and advanced usage.
 
 ```python
 from fastmcp import FastMCP, Client
@@ -232,29 +232,3 @@ This customization is useful when you want to:
 <Tip>
 If the serializer function raises an exception, the tool will fall back to the default JSON serialization to avoid breaking the server.
 </Tip>
-
-## Authentication
-
-<VersionBadge version="2.2.7" />
-
-FastMCP supports OAuth 2.0 authentication, allowing servers to protect their tools and resources. This is configured by providing an `auth_server_provider` and `auth` settings during `FastMCP` initialization.
-
-```python
-from fastmcp import FastMCP
-from mcp.server.auth.settings import AuthSettings #, ... other auth imports
-# from your_auth_implementation import MyOAuthServerProvider # Placeholder
-
-# Create a server with authentication (conceptual example)
-# mcp = FastMCP(
-#     name="SecureApp",
-#     auth_server_provider=MyOAuthServerProvider(),
-#     auth=AuthSettings(
-#         issuer_url="https://myapp.com",
-#         # ... other OAuth settings ...
-#         required_scopes=["myscope"],
-#     ),
-# )
-```
-Due to the low-level nature of the current MCP SDK's auth provider interface, detailed implementation is beyond a quick example. Refer to the [MCP SDK documentation](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) for specifics on implementing an `OAuthAuthorizationServerProvider`. FastMCP integrates with this by passing the provider and settings to the underlying MCP server.
-
-A dedicated [Authentication guide](/deployment/authentication) will cover this in more detail once higher-level abstractions are available in FastMCP.

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/snippets/version-badge.mdx

@@ -1,13 +1,12 @@
 export const VersionBadge = ({ version }) => {
     return (
         <code className="version-badge-container">
-            <div className="version-badge">
+            <p className="version-badge">
                 <span className="version-badge-label">New in version:</span>&nbsp;
-                <span className="version-badge-version">{version}</span>
-            </div>
+                <code className="version-badge-version">{version}</code>
+            </p>
         </code>
 
 
-
     );
 };

{fastmcp-2.6.0 → fastmcp-2.6.1}/docs/style.css

@@ -17,16 +17,18 @@ h6 code:not(pre code) {
   display: inline-block;
   align-items: center;
   gap: 0.3em;
-  padding: 0.2em 0.8em;
-  font-size: 1.1em;
-  font-weight: 400;
-
+  font-size: 1em;
+  margin-top: 0px;
+  margin-bottom: 0px;
+  padding-top: 6px;
+  padding-bottom: 6px;
+  padding-left: 20px;
+  padding-right: 20px;
   font-family: "Inter", sans-serif;
-  letter-spacing: 0.025em;
   color: #ff5400;
-  background: #ffeee6;
-  border: 1px solid rgb(255, 84, 0, 0.5);
-  border-radius: 6px;
+  background: #fef2f2;
+  border: 1px solid rgba(220, 38, 38, 0.3);
+  border-radius: 12px;
   box-shadow: none;
   vertical-align: middle;
   position: relative;
@@ -44,7 +46,7 @@ h6 code:not(pre code) {
 }
 
 .dark .version-badge {
-  color: #fff;
-  background: #312e81;
-  border: 1.5px solid #a78bfa;
+  color: #f1f5f9;
+  background: #334155;
+  border: 1px solid #64748b;
 }

{fastmcp-2.6.0 → fastmcp-2.6.1}/src/fastmcp/client/auth/oauth.py

@@ -68,9 +68,6 @@ class ServerOAuthMetadata(_MCPServerOAuthMetadata):
 class OAuthClientProvider(_MCPOAuthClientProvider):
     """
     OAuth client provider with more flexible OAuth metadata discovery.
-
-    This subclass handles real-world OAuth servers that may not conform
-    strictly to the MCP OAuth specification but are still valid OAuth 2.0 servers.
     """
 
     async def _discover_oauth_metadata(

{fastmcp-2.6.0 → fastmcp-2.6.1}/src/fastmcp/server/auth/providers/in_memory.py

@@ -1,8 +1,3 @@
-"""
-This is a simple in-memory OAuth provider for testing purposes.
-It simulates the OAuth 2.0 flow locally without external calls.
-"""
-
 import secrets
 import time
 
@@ -36,7 +31,7 @@ DEFAULT_REFRESH_TOKEN_EXPIRY_SECONDS = None  # No expiry
 class InMemoryOAuthProvider(OAuthProvider):
     """
     An in-memory OAuth provider for testing purposes.
-    It simulates the OAuth 2.0 flow locally without external calls.
+    It simulates the OAuth 2.1 flow locally without external calls.
     """
 
     def __init__(

{fastmcp-2.6.0 → fastmcp-2.6.1}/src/fastmcp/server/server.py

@@ -131,16 +131,6 @@ class FastMCP(Generic[LifespanResultT]):
         tools: list[Tool | Callable[..., Any]] | None = None,
         **settings: Any,
     ):
-        if settings:
-            # TODO: remove settings. Deprecated since 2.3.4
-            warnings.warn(
-                "Passing runtime and transport-specific settings as kwargs "
-                "to the FastMCP constructor is deprecated (as of 2.3.4), "
-                "including most transport settings. If possible, provide settings when calling "
-                "run() instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
         self.settings = fastmcp.settings.ServerSettings(**settings)
 
         # If mask_error_details is provided, override the settings value

{fastmcp-2.6.0 → fastmcp-2.6.1}/tests/deprecated/test_deprecated.py

@@ -9,17 +9,6 @@ from starlette.applications import Starlette
 from fastmcp import Client, FastMCP
 
 
-def test_fastmcp_kwargs_settings_deprecation_warning():
-    """Test that passing settings as kwargs to FastMCP raises a deprecation warning."""
-    with pytest.warns(
-        DeprecationWarning,
-        match="Passing runtime and transport-specific settings as kwargs to the FastMCP constructor is deprecated",
-    ):
-        server = FastMCP("TestServer", host="127.0.0.2", port=8001)
-        assert server.settings.host == "127.0.0.2"
-        assert server.settings.port == 8001
-
-
 def test_sse_app_deprecation_warning():
     """Test that sse_app raises a deprecation warning."""
     server = FastMCP("TestServer")

{fastmcp-2.6.0 → fastmcp-2.6.1}/tests/server/test_auth_integration.py

@@ -342,7 +342,7 @@ async def tokens(test_client, registered_client, auth_code, pkce_challenge, requ
 
 class TestAuthEndpoints:
     async def test_metadata_endpoint(self, test_client: httpx.AsyncClient):
-        """Test the OAuth 2.0 metadata endpoint."""
+        """Test the OAuth 2.1 metadata endpoint."""
         print("Sending request to metadata endpoint")
         response = await test_client.get("/.well-known/oauth-authorization-server")
         print(f"Got response: {response.status_code}")