fastmcp 0.3.0__tar.gz → 0.3.1__tar.gz

{fastmcp-0.3.0 → fastmcp-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastmcp
-Version: 0.3.0
+Version: 0.3.1
 Summary: A more ergonomic interface for MCP servers
 Author: Jeremiah Lowin
 License: Apache-2.0
@@ -22,7 +22,7 @@ Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <!-- omit in toc -->
-# FastMCP 
+# FastMCP 🚀
 
 <div align="center">
 
@@ -30,17 +30,36 @@ Description-Content-Type: text/markdown
 [![Tests](https://github.com/jlowin/fastmcp/actions/workflows/run-tests.yml/badge.svg)](https://github.com/jlowin/fastmcp/actions/workflows/run-tests.yml)
 [![License](https://img.shields.io/github/license/jlowin/fastmcp.svg)](https://github.com/jlowin/fastmcp/blob/main/LICENSE)
 
+A fast, Pythonic way to build [Model Context Protocol (MCP)](https://modelcontextprotocol.io) servers
+
 </div>
 
-FastMCP is a high-level, intuitive framework for building [Model Context Protocol (MCP)](https://modelcontextprotocol.io) servers with Python. While MCP is a powerful protocol that enables LLMs to interact with local data and tools in a secure, standardized way, the specification can be cumbersome to implement directly. FastMCP lets you build fully compliant MCP servers in the most Pythonic way possible - in many cases, simply decorating a function is all that's required.
+FastMCP makes building MCP servers simple and intuitive. Create tools, expose resources, and define prompts with clean, Pythonic code:
 
-🚧 *Note: FastMCP is under active development, as is the low-level MCP Python SDK* 🏗️
+```python
+from fastmcp import FastMCP
+
+mcp = FastMCP("Demo 🚀")
+
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+```
+
+That's it! 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.
+
+
+### Key features:
+* **Fast**: High-level interface means less code and faster development
+* **Simple**: Build MCP servers with minimal boilerplate
+* **Pythonic**: Feels natural to Python developers
+* **Complete***: FastMCP aims to provide a full implementation of the core MCP specification
+
+(\*emphasis on *aims*)
+
+🚨 🚧 🏗️ *FastMCP is under active development, as is the MCP specification itself. Core features are working but some advanced capabilities are still in progress.* 
 
-Key features:
-* **Intuitive**: Designed to feel familiar to Python developers, with powerful type hints and editor support
-* **Simple**: Build compliant MCP servers with minimal boilerplate
-* **Fast**: High-performance async implementation
-* **Full-featured**: Complete implementation of the MCP specification
 
 <!-- omit in toc -->
 ## Table of Contents
@@ -113,19 +132,21 @@ fastmcp install server.py
 fastmcp dev server.py
 ```
 
-![MCP Inspector](docs/images/mcp-inspector.png)
+![MCP Inspector](/docs/assets/demo-inspector.png)
 
 ## 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:
 
-- Expose data through **Resources** (like GET endpoints)
-- Provide functionality through **Tools** (like POST endpoints)
+- 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!
+
+There is a low-level [Python SDK](https://github.com/modelcontextprotocol/python-sdk) available for implementing the protocol directly, but FastMCP aims to make that easier by providing a high-level, Pythonic interface.
 
 ## Core Concepts
 
-*Note: All code examples below assume you've created a FastMCP server instance called `mcp`.*
 
 ### Server
 
@@ -140,6 +161,7 @@ mcp = FastMCP("My App")
 # Configure host/port for HTTP transport (optional)
 mcp = FastMCP("My App", host="localhost", port=8000)
 ```
+*Note: All of the following code examples assume you've created a FastMCP server instance called `mcp`, as shown above.*
 
 ### Resources
 
@@ -382,4 +404,4 @@ Schema:
 {get_schema()}
 
 What insights can you provide about the structure and relationships?"""
-```
+```

{fastmcp-0.3.0 → fastmcp-0.3.1}/README.md

@@ -1,5 +1,5 @@
 <!-- omit in toc -->
-# FastMCP 
+# FastMCP 🚀
 
 <div align="center">
 
@@ -7,17 +7,36 @@
 [![Tests](https://github.com/jlowin/fastmcp/actions/workflows/run-tests.yml/badge.svg)](https://github.com/jlowin/fastmcp/actions/workflows/run-tests.yml)
 [![License](https://img.shields.io/github/license/jlowin/fastmcp.svg)](https://github.com/jlowin/fastmcp/blob/main/LICENSE)
 
+A fast, Pythonic way to build [Model Context Protocol (MCP)](https://modelcontextprotocol.io) servers
+
 </div>
 
-FastMCP is a high-level, intuitive framework for building [Model Context Protocol (MCP)](https://modelcontextprotocol.io) servers with Python. While MCP is a powerful protocol that enables LLMs to interact with local data and tools in a secure, standardized way, the specification can be cumbersome to implement directly. FastMCP lets you build fully compliant MCP servers in the most Pythonic way possible - in many cases, simply decorating a function is all that's required.
+FastMCP makes building MCP servers simple and intuitive. Create tools, expose resources, and define prompts with clean, Pythonic code:
 
-🚧 *Note: FastMCP is under active development, as is the low-level MCP Python SDK* 🏗️
+```python
+from fastmcp import FastMCP
+
+mcp = FastMCP("Demo 🚀")
+
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+```
+
+That's it! 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.
+
+
+### Key features:
+* **Fast**: High-level interface means less code and faster development
+* **Simple**: Build MCP servers with minimal boilerplate
+* **Pythonic**: Feels natural to Python developers
+* **Complete***: FastMCP aims to provide a full implementation of the core MCP specification
+
+(\*emphasis on *aims*)
+
+🚨 🚧 🏗️ *FastMCP is under active development, as is the MCP specification itself. Core features are working but some advanced capabilities are still in progress.* 
 
-Key features:
-* **Intuitive**: Designed to feel familiar to Python developers, with powerful type hints and editor support
-* **Simple**: Build compliant MCP servers with minimal boilerplate
-* **Fast**: High-performance async implementation
-* **Full-featured**: Complete implementation of the MCP specification
 
 <!-- omit in toc -->
 ## Table of Contents
@@ -90,19 +109,21 @@ fastmcp install server.py
 fastmcp dev server.py
 ```
 
-![MCP Inspector](docs/images/mcp-inspector.png)
+![MCP Inspector](/docs/assets/demo-inspector.png)
 
 ## 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:
 
-- Expose data through **Resources** (like GET endpoints)
-- Provide functionality through **Tools** (like POST endpoints)
+- 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!
+
+There is a low-level [Python SDK](https://github.com/modelcontextprotocol/python-sdk) available for implementing the protocol directly, but FastMCP aims to make that easier by providing a high-level, Pythonic interface.
 
 ## Core Concepts
 
-*Note: All code examples below assume you've created a FastMCP server instance called `mcp`.*
 
 ### Server
 
@@ -117,6 +138,7 @@ mcp = FastMCP("My App")
 # Configure host/port for HTTP transport (optional)
 mcp = FastMCP("My App", host="localhost", port=8000)
 ```
+*Note: All of the following code examples assume you've created a FastMCP server instance called `mcp`, as shown above.*
 
 ### Resources
 
@@ -359,4 +381,4 @@ Schema:
 {get_schema()}
 
 What insights can you provide about the structure and relationships?"""
-```
+```

{fastmcp-0.3.0 → fastmcp-0.3.1}/src/fastmcp/cli/cli.py

@@ -13,7 +13,7 @@ from typing_extensions import Annotated
 from ..utilities.logging import get_logger
 from . import claude
 
-logger = get_logger(__name__)
+logger = get_logger("cli")
 
 app = typer.Typer(
     name="fastmcp",
@@ -263,7 +263,7 @@ def run(
 
     except Exception as e:
         logger.error(
-            "Failed to run server",
+            f"Failed to run server: {e}",
             extra={
                 "file": str(file),
                 "error": str(e),
@@ -352,7 +352,7 @@ def install(
         with_packages=with_packages,
         force=force,
     ):
-        print(f"Successfully installed {name} in Claude app")
+        logger.info(f"Successfully installed {name} in Claude app")
     else:
-        print(f"Failed to install {name} in Claude app")
+        logger.error(f"Failed to install {name} in Claude app")
         sys.exit(1)

{fastmcp-0.3.0 → fastmcp-0.3.1}/src/fastmcp/server.py

@@ -53,7 +53,11 @@ class Settings(BaseSettings):
     For example, FASTMCP_DEBUG=true will set debug=True.
     """
 
-    model_config: SettingsConfigDict = SettingsConfigDict(env_prefix="FASTMCP_")
+    model_config: SettingsConfigDict = SettingsConfigDict(
+        env_prefix="FASTMCP_",
+        env_file=".env",
+        extra="ignore",
+    )
 
     # Server settings
     debug: bool = False
@@ -400,7 +404,6 @@ class FastMCP:
     async def run_stdio_async(self) -> None:
         """Run the server using stdio transport."""
         async with stdio_server() as (read_stream, write_stream):
-            logger.info(f'Starting "{self.name}"...')
             await self._mcp_server.run(
                 read_stream,
                 write_stream,

{fastmcp-0.3.0 → fastmcp-0.3.1}/src/fastmcp/utilities/logging.py

@@ -3,15 +3,17 @@
 import logging
 from typing import Literal
 
+from rich.logging import RichHandler
+
 
 def get_logger(name: str) -> logging.Logger:
     """Get a logger nested under FastMCP namespace.
 
     Args:
-        name: The name of the logger, which will be prefixed with 'FastMCP.'
+        name: the name of the logger, which will be prefixed with 'FastMCP.'
 
     Returns:
-        A configured logger instance
+        a configured logger instance
     """
     return logging.getLogger(f"FastMCP.{name}")
 
@@ -22,9 +24,8 @@ def configure_logging(
     """Configure logging for FastMCP.
 
     Args:
-        level: The log level to use
+        level: the log level to use
     """
     logging.basicConfig(
-        level=level,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        level=level, format="%(message)s", handlers=[RichHandler(rich_tracebacks=True)]
     )

{fastmcp-0.3.0 → fastmcp-0.3.1}/uv.lock

@@ -228,7 +228,7 @@ wheels = [
 
 [[package]]
 name = "fastmcp"
-version = "0.2.1.dev56+g0fb37ec.d20241201"
+version = "0.3.1.dev3+g35b0931.d20241201"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },