fastmcp 2.1.2__tar.gz → 2.2.0__tar.gz

{fastmcp-2.1.2 → fastmcp-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.1.2
+Version: 2.2.0
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -18,7 +18,8 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: dotenv>=0.9.9
-Requires-Dist: fastapi>=0.115.12
+Requires-Dist: exceptiongroup>=1.2.2
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: mcp<2.0.0,>=1.6.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: rich>=13.9.4
@@ -121,7 +122,7 @@ FastMCP provides a high-level, Pythonic interface for building and interacting w
 
 ## 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.
+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.
 
 FastMCP aims to be:
 
@@ -580,13 +581,13 @@ proxy_client = Client(
 )
 
 # Create a proxy server that connects to the client and exposes its capabilities
-proxy = FastMCP.as_proxy(proxy_client, name="Stdio-to-SSE Proxy")
+proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")
 
 if __name__ == "__main__":
     proxy.run(transport='sse')
 ```
 
-`FastMCP.as_proxy` is an `async` classmethod. It connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
+`FastMCP.from_client` is a class method that connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
 
 
 

{fastmcp-2.1.2 → fastmcp-2.2.0}/README.md

@@ -93,7 +93,7 @@ FastMCP provides a high-level, Pythonic interface for building and interacting w
 
 ## 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.
+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.
 
 FastMCP aims to be:
 
@@ -552,13 +552,13 @@ proxy_client = Client(
 )
 
 # Create a proxy server that connects to the client and exposes its capabilities
-proxy = FastMCP.as_proxy(proxy_client, name="Stdio-to-SSE Proxy")
+proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")
 
 if __name__ == "__main__":
     proxy.run(transport='sse')
 ```
 
-`FastMCP.as_proxy` is an `async` classmethod. It connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
+`FastMCP.from_client` is a class method that connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
 
 
 

fastmcp-2.1.2/docs/clients/overview.mdx → fastmcp-2.2.0/docs/clients/client.mdx

@@ -5,6 +5,10 @@ description: Learn how to use the FastMCP Client to interact with MCP servers.
 icon: user-robot
 ---
 
+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.
 
 ## FastMCP Client
@@ -248,5 +252,5 @@ async def safe_call_tool():
 Other errors, like connection failures, will raise standard Python exceptions (e.g., `ConnectionError`, `TimeoutError`). 
 
 <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 call `call_tools(..., return_raw_result=True)` to get the raw result object and handle errors yourself by checking its `isError` attribute.
+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 call `call_tool(..., _return_raw_result=True)` to get the raw `mcp.types.CallToolResult` object and handle errors yourself by checking its `isError` attribute.
 </Tip>

{fastmcp-2.1.2 → fastmcp-2.2.0}/docs/clients/transports.mdx

@@ -7,7 +7,7 @@ icon: link
 
 The FastMCP `Client` relies on a `ClientTransport` object to handle the specifics of connecting to and communicating with an MCP server. FastMCP provides several built-in transport implementations for common connection methods.
 
-While the `Client` often infers the correct transport automatically (see [Client Overview](/clients/overview#transport-inference)), you can also instantiate transports explicitly for more control.
+While the `Client` often infers the correct transport automatically (see [Client Overview](/clients/client#transport-inference)), you can also instantiate transports explicitly for more control.
 
 
 ## Stdio Transports

{fastmcp-2.1.2 → fastmcp-2.2.0}/docs/docs.json

@@ -50,14 +50,14 @@
             {
                 "group": "Clients",
                 "pages": [
-                    "clients/overview",
+                    "clients/client",
                     "clients/transports"
                 ]
             },
             {
                 "group": "Patterns",
                 "pages": [
-                    "patterns/proxying",
+                    "patterns/proxy",
                     "patterns/composition",
                     "patterns/decorating-methods",
                     "patterns/openapi",

fastmcp-2.2.0/docs/patterns/composition.mdx

@@ -0,0 +1,297 @@
+---
+title: Server Composition
+sidebarTitle: Composition
+description: Combine multiple FastMCP servers into a single, larger application using mounting and importing.
+icon: puzzle-piece
+---
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.2.0" />
+
+As your MCP applications grow, you might want to organize your tools, resources, and prompts into logical modules or reuse existing server components. FastMCP supports composition through two methods:
+
+- **`import_server`**: For a one-time copy of components with prefixing (static composition).
+- **`mount`**: For creating a live link where the main server delegates requests to the subserver (dynamic composition).
+
+## Why Compose Servers?
+
+-   **Modularity**: Break down large applications into smaller, focused servers (e.g., a `WeatherServer`, a `DatabaseServer`, a `CalendarServer`).
+-   **Reusability**: Create common utility servers (e.g., a `TextProcessingServer`) and mount them wherever needed.
+-   **Teamwork**: Different teams can work on separate FastMCP servers that are later combined.
+-   **Organization**: Keep related functionality grouped together logically.
+
+### Importing vs Mounting
+
+The choice of importing or mounting depends on your use case and requirements. In general, importing is best for simpler cases because it copies the imported server's components into the main server, treating them as native integrations. Mounting is best for more complex cases where you need to delegate requests to the subserver at runtime.
+
+
+| Feature | Importing | Mounting |
+|---------|----------------|---------|
+| **Method** | `FastMCP.import_server()` | `FastMCP.mount()` |
+| **Composition Type** | One-time copy (static) | Live link (dynamic) |
+| **Updates** | Changes to subserver NOT reflected | Changes to subserver immediately reflected |
+| **Lifespan** | Not managed | Automatically managed |
+| **Synchronicity** | Async (must be awaited) | Sync |
+| **Best For** | Bundling finalized components | Modular runtime composition |
+
+### 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.
+
+
+## Importing (Static Composition)
+
+The `import_server()` method copies all components (tools, resources, templates, prompts) from one `FastMCP` instance (the *subserver*) into another (the *main server*). A `prefix` is added to avoid naming conflicts.
+
+```python
+from fastmcp import FastMCP
+import asyncio
+
+# --- Define Subservers ---
+
+# Weather Service
+weather_mcp = FastMCP(name="WeatherService")
+
+@weather_mcp.tool()
+def get_forecast(city: str) -> dict:
+    """Get weather forecast."""
+    return {"city": city, "forecast": "Sunny"}
+
+@weather_mcp.resource("data://cities/supported")
+def list_supported_cities() -> list[str]:
+    """List cities with weather support."""
+    return ["London", "Paris", "Tokyo"]
+
+# Calculator Service
+calc_mcp = FastMCP(name="CalculatorService")
+
+@calc_mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers."""
+    return a + b
+
+@calc_mcp.prompt()
+def explain_addition() -> str:
+    """Explain the concept of addition."""
+    return "Addition is the process of combining two or more numbers."
+
+# --- Define Main Server ---
+main_mcp = FastMCP(name="MainApp")
+
+# --- Import Subservers ---
+async def setup():
+    # Import weather service with prefix "weather"
+    await main_mcp.import_server("weather", weather_mcp)
+
+    # Import calculator service with prefix "calc"
+    await main_mcp.import_server("calc", calc_mcp)
+
+# --- Now, main_mcp contains *copied* components ---
+# Tools:
+# - "weather_get_forecast"
+# - "calc_add"
+# Resources:
+# - "weather+data://cities/supported" (prefixed URI)
+# Prompts:
+# - "calc_explain_addition"
+
+if __name__ == "__main__":
+    # In a real app, you might run this async or setup imports differently
+    asyncio.run(setup())
+    # Run the main server, which now includes components from both subservers
+    main_mcp.run()
+```
+
+### How Importing Works
+
+When you call `await main_mcp.import_server(prefix, subserver)`:
+
+1.  **Tools**: All tools from `subserver` are added to `main_mcp`. Their names are automatically prefixed using the `prefix` and a default separator (`_`).
+    -   `subserver.tool(name="my_tool")` becomes `main_mcp.tool(name="{prefix}_my_tool")`.
+2.  **Resources**: All resources from `subserver` are added. Their URIs are prefixed using the `prefix` and a default separator (`+`).
+    -   `subserver.resource(uri="data://info")` becomes `main_mcp.resource(uri="{prefix}+data://info")`.
+3.  **Resource Templates**: All templates from `subserver` are added. Their URI *templates* are prefixed similarly to resources.
+    -   `subserver.resource(uri="data://{id}")` becomes `main_mcp.resource(uri="{prefix}+data://{id}")`.
+4.  **Prompts**: All prompts from `subserver` are added, with names prefixed like tools.
+    -   `subserver.prompt(name="my_prompt")` becomes `main_mcp.prompt(name="{prefix}_my_prompt")`.
+
+Note that `import_server` performs a **one-time copy** of components from the `subserver` into the `main_mcp` instance at the time the method is called. Changes made to the `subserver` *after* `import_server` is called **will not** be reflected in `main_mcp`. Also, the `subserver`'s `lifespan` context is **not** executed by the main server when using `import_server`.
+
+### Customizing Separators
+
+You might prefer different separators for the prefixed names and URIs. You can customize these when calling `import_server()`:
+
+```python
+await main_mcp.import_server(
+    prefix="api",
+    app=some_subserver,
+    tool_separator="/",       # Tool name becomes: "api/sub_tool_name"
+    resource_separator=":",   # Resource URI becomes: "api:data://sub_resource"
+    prompt_separator="."      # Prompt name becomes: "api.sub_prompt_name"
+)
+```
+
+<Warning>
+Be cautious when choosing separators. Some MCP clients (like Claude Desktop) might have restrictions on characters allowed in tool names (e.g., `/` might not be supported). The defaults (`_` for names, `+` for URIs) are generally safe.
+</Warning>
+
+## Mounting (Live Linking)
+
+The `mount()` method creates a **live link** between the `main_mcp` server and the `subserver`. Instead of copying components, requests for components matching the `prefix` are **delegated** to the `subserver` at runtime.
+
+```python
+import asyncio
+from fastmcp import FastMCP, Client
+
+# --- Define Subserver ---
+dynamic_mcp = FastMCP(name="DynamicService")
+@dynamic_mcp.tool()
+def initial_tool(): return "Initial Tool Exists"
+
+# --- Define Main Server ---
+main_mcp = FastMCP(name="MainAppLive")
+
+# --- Mount Subserver (Sync operation) ---
+main_mcp.mount("dynamic", dynamic_mcp)
+
+print("Mounted dynamic_mcp.")
+
+# --- Add a tool AFTER mounting ---
+@dynamic_mcp.tool()
+def added_later(): return "Tool Added Dynamically!"
+
+print("Added 'added_later' tool to dynamic_mcp.")
+
+# --- Test Access ---
+async def test_dynamic_mount():
+    # Need to use await for get_tools now
+    tools_before = await main_mcp.get_tools()
+    print("Tools available via main_mcp:", list(tools_before.keys()))
+    # Expected: ['dynamic_initial_tool', 'dynamic_added_later']
+
+    async with Client(main_mcp) as client:
+        # Call the dynamically added tool via the main server
+        result = await client.call_tool("dynamic_added_later")
+        print("Result of calling dynamic_added_later:", result[0].text)
+        # Expected: Tool Added Dynamically!
+
+if __name__ == "__main__":
+     # Need async context to test
+     asyncio.run(test_dynamic_mount())
+     # To run the server itself:
+     # main_mcp.run()
+```
+
+### How Mounting Works
+
+When you call `main_mcp.mount(prefix, server)`:
+
+1. **Live Link**: A live connection is established between `main_mcp` and the `subserver`.
+2. **Dynamic Updates**: Changes made to the `subserver` (e.g., adding new tools) **will be reflected** immediately when accessing components through `main_mcp`.
+3. **Lifespan Management**: The `subserver`'s `lifespan` context **is automatically managed** and executed within the `main_mcp`'s lifespan.
+4. **Delegation**: Requests for components matching the prefix are delegated to the subserver at runtime.
+
+The same prefixing rules apply as with `import_server` for naming tools, resources, templates, and prompts.
+
+### Customizing Separators
+
+Similar to `import_server`, you can customize the separators for the prefixed names and URIs:
+
+```python
+main_mcp.mount(
+    prefix="api",
+    app=some_subserver,
+    tool_separator="/",       # Tool name becomes: "api/sub_tool_name"
+    resource_separator=":",   # Resource URI becomes: "api:data://sub_resource"
+    prompt_separator="."      # Prompt name becomes: "api.sub_prompt_name"
+)
+```
+
+
+## Example: Modular Application
+
+Here's how a modular application might use `import_server`:
+
+<CodeGroup>
+```python main.py
+from fastmcp import FastMCP
+import asyncio
+
+# Import the servers (see other files)
+from modules.text_server import text_mcp
+from modules.data_server import data_mcp
+
+app = FastMCP(name="MainApplication")
+
+# Setup function for async imports
+async def setup():
+    # Import the utility servers
+    await app.import_server("text", text_mcp)
+    await app.import_server("data", data_mcp)
+
+@app.tool()
+def process_and_analyze(record_id: int) -> str:
+    """Fetches a record and analyzes its string representation."""
+    # In a real application, you'd use proper methods to interact between
+    # imported tools rather than accessing internal managers
+    
+    # Get record data
+    record = {"id": record_id, "value": random.random()}
+    
+    # Count words in the record string representation
+    word_count = len(str(record).split())
+    
+    return (
+        f"Record {record_id} has {word_count} words in its string "
+        f"representation."
+    )
+
+if __name__ == "__main__":
+    # Run async setup before starting the server
+    asyncio.run(setup())
+    # Run the server
+    app.run()
+```
+```python modules/text_server.py
+from fastmcp import FastMCP
+
+text_mcp = FastMCP(name="TextUtilities")
+
+@text_mcp.tool()
+def count_words(text: str) -> int:
+    """Counts words in a text."""
+    return len(text.split())
+
+@text_mcp.resource("resource://stopwords")
+def get_stopwords() -> list[str]:
+    """Return a list of common stopwords."""
+    return ["the", "a", "is", "in"]
+```
+
+```python modules/data_server.py
+from fastmcp import FastMCP
+import random
+from typing import dict
+
+data_mcp = FastMCP(name="DataAPI")
+
+@data_mcp.tool()
+def fetch_record(record_id: int) -> dict:
+    """Fetches a dummy data record."""
+    return {"id": record_id, "value": random.random()}
+
+@data_mcp.resource("data://schema/{table}")
+def get_table_schema(table: str) -> dict:
+    """Provides a dummy schema for a table."""
+    return {"table": table, "columns": ["id", "value"]}
+```
+
+</CodeGroup>
+Now, running `main.py` starts a server that exposes:
+- `text_count_words`
+- `data_fetch_record`
+- `process_and_analyze`
+- `text+resource://stopwords`
+- `data+data://schema/{table}` (template)
+
+This pattern promotes code organization and reuse within your FastMCP projects. 

fastmcp-2.2.0/docs/patterns/fastapi.mdx

@@ -0,0 +1,123 @@
+---
+title: FastAPI Integration
+sidebarTitle: FastAPI
+description: Generate MCP servers from FastAPI apps
+icon: square-bolt
+---
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+
+FastMCP can automatically convert FastAPI applications into MCP servers.
+
+<Tip>
+FastMCP does *not* include FastAPI as a dependency; you must install it separately to run these examples.
+</Tip>
+
+
+```python {2, 22, 25}
+from fastapi import FastAPI
+from fastmcp import FastMCP
+
+
+# A FastAPI app
+app = FastAPI()
+
+@app.get("/items")
+def list_items():
+    return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]
+
+@app.get("/items/{item_id}")
+def get_item(item_id: int):
+    return {"id": item_id, "name": f"Item {item_id}"}
+
+@app.post("/items")
+def create_item(name: str):
+    return {"id": 3, "name": name}
+
+
+# Create an MCP server from your FastAPI app
+mcp = FastMCP.from_fastapi(app=app)
+
+if __name__ == "__main__":
+    mcp.run()  # Start the MCP server
+```
+
+## Route Mapping
+
+By default, FastMCP will map FastAPI routes to MCP components according to the following rules:
+
+| FastAPI Route Type | FastAPI Example | MCP Component | Notes |
+|--------------------|--------------|---------|-------|
+| GET without path params | `@app.get("/stats")` | Resource | Simple resources for fetching data |
+| GET with path params | `@app.get("/users/{id}")` | Resource Template | Path parameters become template parameters |
+| POST, PUT, DELETE, etc. | `@app.post("/users")` | Tool | Operations that modify data |
+
+For more details on route mapping or custom mapping rules, see the [OpenAPI integration documentation](/patterns/openapi#route-mapping); FastMCP uses the same mapping rules for both FastAPI and OpenAPI integrations.
+
+## Complete Example
+
+Here's a more detailed example with a data model:
+
+```python
+import asyncio
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from fastmcp import FastMCP, Client
+
+# Define your Pydantic model
+class Item(BaseModel):
+    name: str
+    price: float
+
+# Create your FastAPI app
+app = FastAPI()
+items = {}  # In-memory database
+
+@app.get("/items")
+def list_items():
+    """List all items"""
+    return list(items.values())
+
+@app.get("/items/{item_id}")
+def get_item(item_id: int):
+    """Get item by ID"""
+    if item_id not in items:
+        raise HTTPException(404, "Item not found")
+    return items[item_id]
+
+@app.post("/items")
+def create_item(item: Item):
+    """Create a new item"""
+    item_id = len(items) + 1
+    items[item_id] = {"id": item_id, **item.model_dump()}
+    return items[item_id]
+
+# Test your MCP server with a client
+async def test():
+    # Create MCP server from FastAPI app
+    mcp = await FastMCP.from_fastapi(app=app)
+    
+    # List the components that were created
+    tools = await mcp.list_tools()
+    resources = await mcp.list_resources()
+    templates = await mcp.list_resource_templates()
+    
+    print(f"Generated {len(tools)} tools")
+    print(f"Generated {len(resources)} resources")
+    print(f"Generated {len(templates)} templates")
+    
+    # In a real scenario, you would run the server:
+    # mcp.run()
+
+if __name__ == "__main__":
+    asyncio.run(test())
+```
+
+## Benefits
+
+- **Leverage existing FastAPI apps** - No need to rewrite your API logic
+- **Schema reuse** - FastAPI's Pydantic models and validation are inherited
+- **Full feature support** - Works with FastAPI's authentication, dependencies, etc.
+- **ASGI transport** - Direct communication without additional HTTP overhead

fastmcp-2.2.0/docs/patterns/openapi.mdx

@@ -0,0 +1,156 @@
+---
+title: OpenAPI Integration
+sidebarTitle: OpenAPI
+description: Generate MCP servers from OpenAPI specs
+icon: code-branch
+---
+import { VersionBadge } from '/snippets/version-badge.mdx'
+
+<VersionBadge version="2.0.0" />
+
+FastMCP can automatically generate an MCP server from an OpenAPI specification. Users only need to provide an OpenAPI specification (3.0 or 3.1) and an API client.
+
+```python
+import httpx
+from fastmcp import FastMCP
+
+# Create a client for your API
+api_client = httpx.AsyncClient(base_url="https://api.example.com")
+
+# Load your OpenAPI spec
+spec = {...} 
+
+# Create an MCP server from your OpenAPI spec
+mcp = FastMCP.from_openapi(openapi_spec=spec, client=api_client)
+
+if __name__ == "__main__":
+    mcp.run()
+```
+
+## Route Mapping
+
+By default, OpenAPI routes are mapped to MCP components based on these rules:
+
+| OpenAPI Route | Example |MCP Component | Notes |
+|- | - | - | - |
+| `GET` without path params | `GET /stats` | Resource | Simple resources for fetching data |
+| `GET` with path params | `GET /users/{id}` | Resource Template | Path parameters become template parameters |
+| `POST`, `PUT`, `PATCH`, `DELETE`, etc. | `POST /users` | Tool | Operations that modify data |
+
+
+Internally, FastMCP uses a priority-ordered set of `RouteMap` objects to determine the component type. Route maps indicate that a specific HTTP method (or methods) and path pattern should be treated as a specific component type. This is the default set of route maps:
+
+```python
+# Simplified version of the actual mapping rules
+DEFAULT_ROUTE_MAPPINGS = [
+    # GET with path parameters -> ResourceTemplate
+    RouteMap(methods=["GET"], pattern=r".*\{.*\}.*", 
+             route_type=RouteType.RESOURCE_TEMPLATE),
+    
+    # GET without path parameters -> Resource
+    RouteMap(methods=["GET"], pattern=r".*", 
+             route_type=RouteType.RESOURCE),
+    
+    # All other methods -> Tool
+    RouteMap(methods=["POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"],
+             pattern=r".*", route_type=RouteType.TOOL),
+]
+```
+
+### Custom Route Maps
+
+Users can add custom route maps to override the default mapping behavior. User-supplied route maps are always applied first, before the default route maps.
+
+```python
+from fastmcp.server.openapi import RouteMap, RouteType
+
+# Custom mapping rules
+custom_maps = [
+    # Force all analytics endpoints to be Tools
+    RouteMap(methods=["GET"], 
+             pattern=r"^/analytics/.*", 
+             route_type=RouteType.TOOL)
+]
+
+# Apply custom mappings
+mcp = await FastMCP.from_openapi(
+    openapi_spec=spec,
+    client=api_client,
+    route_maps=custom_maps
+)
+```
+
+## How It Works
+
+1. FastMCP parses your OpenAPI spec to extract routes and schemas
+2. It applies mapping rules to categorize each route
+3. When an MCP client calls a tool or accesses a resource:
+   - FastMCP constructs an HTTP request based on the OpenAPI definition
+   - It sends the request through the provided httpx client
+   - It translates the HTTP response to the appropriate MCP format
+
+## Complete Example
+
+```python
+import asyncio
+import httpx
+from fastmcp import FastMCP
+
+# Sample OpenAPI spec for a Pet Store API
+petstore_spec = {
+    "openapi": "3.0.0",
+    "paths": {
+        "/pets": {
+            "get": {
+                "operationId": "listPets",
+                "summary": "List all pets"
+            },
+            "post": {
+                "operationId": "createPet",
+                "summary": "Create a new pet"
+            }
+        },
+        "/pets/{petId}": {
+            "get": {
+                "operationId": "getPet",
+                "summary": "Get a pet by ID",
+                "parameters": [
+                    {
+                        "name": "petId",
+                        "in": "path",
+                        "required": True,
+                        "schema": {"type": "string"}
+                    }
+                ]
+            }
+        }
+    }
+}
+
+async def main():
+    # Client for the Pet Store API
+    client = httpx.AsyncClient(base_url="https://petstore.example.com/api")
+    
+    # Create the MCP server
+    mcp = await FastMCP.from_openapi(
+        openapi_spec=petstore_spec,
+        client=client,
+        name="PetStore"
+    )
+    
+    # List what components were created
+    tools = await mcp.list_tools()
+    resources = await mcp.list_resources()
+    templates = await mcp.list_resource_templates()
+    
+    print(f"Tools: {len(tools)}")          # Should include createPet
+    print(f"Resources: {len(resources)}")  # Should include listPets
+    print(f"Templates: {len(templates)}")  # Should include getPet
+    
+    # Start the MCP server
+    mcp.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+