as_proxy substantially slower

[wbste]

Description

I use FastMCP.as_proxy all the time, but recently I built a new server and made it with acting as a proxy. For certain servers (http streamable at least), Tool execution is substantially slower. Repo:

1. Launch server as is.
2. Open inspector with npx @modelcontextprotocol/inspector
3. Connect via Streamable HTTP to http://localhost:8000/mcp
4. List tools
5. Run the single tool.

Response is instant.

Now swap lines 15 and 16 (so FastMCP.as_proxy... is active).

Create an mcp_test.json in the same directory as the script, then run the same test. Every tool (local and remote) will be much slower to respond.

{
    "mcpServers": {
        "deepwiki": {
            "url": "https://mcp.deepwiki.com/mcp",
            "transport": "http"
        },
        "time": {
            "command": "uvx",
            "args": [
                "mcp-server-time"
            ]
        }
    }
}

Example Code

import json
from datetime import datetime
from pathlib import Path
from zoneinfo import ZoneInfo

from fastmcp import FastMCP

# MARK: Config
config_path = Path("mcp_test.json")
with config_path.open(encoding="utf-8") as f:
    config = json.load(f)


# MARK: FastMCP
# mcp = FastMCP.as_proxy(config, name="Slow MCP", include_fastmcp_meta=False)
mcp = FastMCP(name="Fast MCP", include_fastmcp_meta=False)


@mcp.tool
def custom_get_current_time():
    """Get current time in LA with DST information."""
    now = datetime.now(ZoneInfo("America/Los_Angeles"))
    is_dst = bool(now.dst() and now.dst().total_seconds() != 0) if now.dst() else False
    result = {"timezone": "America/Los_Angeles", "datetime": now.isoformat(), "is_dst": is_dst}
    return json.dumps(result, indent=2)


if __name__ == "__main__":
    mcp.run(transport="http", host="127.0.0.1", port=8000)

Version Information

FastMCP version:                                        2.11.3
MCP version:                                            1.13.1
Python version:                                        3.12.10
Platform:                            Windows-11-10.0.26100-SP0

[jlowin]

How much of a slowdown are you seeing? A proxy server dynamically generates an entire additional MCP handshake between your client and the server so some overhead is normal. It is not a passthrough.

[marvin-context-protocol]

Found 3 possible duplicate issues:

1. mem leak for Mcp server proxy #1261: mem leak for Mcp server proxy
2. Memory leak in fastmcp server under repeated client load #1012: Memory leak in fastmcp server under repeated client load
3. question about performance of proxy server #930: question about performance of proxy server

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

[wbste]

How much of a slowdown are you seeing? A proxy server dynamically generates an entire additional MCP handshake between your client and the server so some overhead is normal. It is not a passthrough.

A few seconds, but only if http remote servers are proxied. Testing a few more atm...local ones don't cause the delay (or at least the time one doesn't).

FYI I tossed the question into deepwiki and got this: https://deepwiki.com/search/when-i-use-asproxy-it-seems-th_c869b03d-ac37-4437-a82e-1a250fc78260

[wbste]

To clarify the problem, it seems the remote http server is causing all tools (even local ones) to execute much slower.

e.g. this as a proxy is fine (when I call local tool custom_get_current_time()):

{
    "mcpServers": {
        "time": {
            "command": "uvx",
            "args": [
                "mcp-server-time"
            ]
        }
    }
}

but if I add the http server (deepwiki and ms docs have been testing so far), and call the same locally-defined tool custom_get_current_time() the reply is much slower.

{
    "mcpServers": {
        "deepwiki": {
            "url": "https://mcp.deepwiki.com/mcp",
            "transport": "http"
        },
        "time": {
            "command": "uvx",
            "args": [
                "mcp-server-time"
            ]
        }
    }
}

[jlowin]

I think this may be a consequence of the low-level SDK now making multiple list_tools() calls for every tool call. IIRC it uses list_tools() to get the input schema prior to calling the tool and the output schema after calling the tool. I think this is a really poor design decision; in this case it results in multiple remote HTTP calls for each tool call. It is supposed to cache the results so I'd be curious if you see the slowdown on a second call. I have really been hoping we won't have to design around this (it's one thing to build on top of the SDK, quite another to forcibly remove its functionality)

[wbste]

I think this may be a consequence of the low-level SDK now making multiple list_tools() calls for every tool call. IIRC it uses list_tools() to get the input schema prior to calling the tool and the output schema after calling the tool. I think this is a really poor design decision; in this case it results in multiple remote HTTP calls for each tool call. It is supposed to cache the results so I'd be curious if you see the slowdown on a second call. I have really been hoping we won't have to design around this (it's one thing to build on top of the SDK, quite another to forcibly remove its functionality)

Yeah I tried making back to back calls; no change in performance. Are the tool calls cached each time?

[wbste]

Yeah pretty rough difference. Maybe just a me problem? I find it hard to believe no one else mentioned it (using same mcp.json above as a starting points [I tested with both the uvx and uvx and http servers in it]):

Client

# client.py
import asyncio
import statistics
import time

from fastmcp import Client
from rich.console import Console
from rich.panel import Panel
from rich.table import Table

console = Console()
client = Client("server.py")


async def main():
    async with client:
        # List tools in panel
        tools = await client.list_tools()
        tools_text = "\n".join([f"• {tool.name}" for tool in tools])
        console.print(Panel(tools_text, title="[bold blue]Available Tools[/bold blue]", expand=False))

        # Running tool calls with table
        console.print(Panel("Running 10 tool calls...", title="[bold green]Benchmark[/bold green]", expand=False))

        table = Table(show_header=True, header_style="bold magenta")
        table.add_column("Name", style="cyan")
        table.add_column("Duration (ms)", justify="right", style="green")

        durations = []
        names = ["Ford", "Arthur", "Zaphod", "Bob", "Trillian", "Marvin", "Slartibartfast", "Deep Thought", "Eddie", "Humma"]

        for name in names:
            start = time.perf_counter()
            await client.call_tool("greet", {"name": name})
            duration = time.perf_counter() - start
            durations.append(duration)
            table.add_row(name, f"{duration * 1000:.1f}")

        console.print(table)

        # Stats in panel
        avg = statistics.mean(durations)
        stats_text = f"avg={avg * 1000:.1f}ms, min={min(durations) * 1000:.1f}ms, max={max(durations) * 1000:.1f}ms"
        console.print(Panel(stats_text, title="[bold]Statistics[/bold]", expand=False))


if __name__ == "__main__":
    asyncio.run(main())

Server

# server.py
import json
from pathlib import Path

from fastmcp import FastMCP

# MARK: Config
config_path = Path("mcp.json")
with config_path.open(encoding="utf-8") as f:
    config = json.load(f)


# MARK: FastMCP
# mcp = FastMCP.as_proxy(config, name="Slow MCP", include_fastmcp_meta=False)
mcp = FastMCP(name="Fast MCP", include_fastmcp_meta=False)


@mcp.tool
def greet(name: str) -> str:
    return f"Hello, {name}!"


if __name__ == "__main__":
    mcp.run()

Results

Slow (STDIO Proxy + HTTP Proxy (Deepwiki) + Local Tool Call)

╭─────── Available Tools ────────╮
│ • greet                        │
│ • deepwiki_read_wiki_structure │
│ • deepwiki_read_wiki_contents  │
│ • deepwiki_ask_question        │
│ • time_get_current_time        │
│ • time_convert_time            │
╰────────────────────────────────╯
╭─────── Benchmark ────────╮
│ Running 10 tool calls... │
╰──────────────────────────╯
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Name           ┃ Duration (ms) ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Ford           │         355.2 │
│ Arthur         │         401.5 │
│ Zaphod         │         308.7 │
│ Bob            │         428.5 │
│ Trillian       │         481.0 │
│ Marvin         │         446.9 │
│ Slartibartfast │         428.3 │
│ Deep Thought   │         331.7 │
│ Eddie          │         315.8 │
│ Humma          │         418.2 │
└────────────────┴───────────────┘
╭───────────── Statistics ──────────────╮
│ avg=391.6ms, min=308.7ms, max=481.0ms │
╰───────────────────────────────────────╯

Slow (STDIO Proxy + HTTP Proxy (MS Docs) + Local Tool Call)

╭─────── Available Tools ────────╮
│ • greet                        │
│ • remote_microsoft_docs_search │
│ • remote_microsoft_docs_fetch  │
│ • local_get_current_time       │
│ • local_convert_time           │
╰────────────────────────────────╯
╭─────── Benchmark ────────╮
│ Running 10 tool calls... │
╰──────────────────────────╯
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Name           ┃ Duration (ms) ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Ford           │         313.4 │
│ Arthur         │         507.6 │
│ Zaphod         │         427.3 │
│ Bob            │         185.4 │
│ Trillian       │         293.6 │
│ Marvin         │         315.8 │
│ Slartibartfast │         369.0 │
│ Deep Thought   │         222.9 │
│ Eddie          │         452.8 │
│ Humma          │         169.6 │
└────────────────┴───────────────┘
╭───────────── Statistics ──────────────╮
│ avg=325.7ms, min=169.6ms, max=507.6ms │
╰───────────────────────────────────────╯

Fast (No Proxy + Local Tool Call)

╭─ Available Tools ─╮
│ • greet           │
╰───────────────────╯
╭─────── Benchmark ────────╮
│ Running 10 tool calls... │
╰──────────────────────────╯
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Name           ┃ Duration (ms) ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Ford           │           2.4 │
│ Arthur         │           1.7 │
│ Zaphod         │           1.7 │
│ Bob            │           1.6 │
│ Trillian       │           1.7 │
│ Marvin         │           1.6 │
│ Slartibartfast │           1.5 │
│ Deep Thought   │           1.6 │
│ Eddie          │           1.4 │
│ Humma          │           1.6 │
└────────────────┴───────────────┘
╭────────── Statistics ───────────╮
│ avg=1.7ms, min=1.4ms, max=2.4ms │
╰─────────────────────────────────╯

Fast (STDIO Proxy + Local Tool Call)

╭─ Available Tools ──╮
│ • greet            │
│ • get_current_time │
│ • convert_time     │
╰────────────────────╯
╭─────── Benchmark ────────╮
│ Running 10 tool calls... │
╰──────────────────────────╯
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Name           ┃ Duration (ms) ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Ford           │           3.9 │
│ Arthur         │           2.8 │
│ Zaphod         │           2.6 │
│ Bob            │           2.8 │
│ Trillian       │           2.8 │
│ Marvin         │           2.9 │
│ Slartibartfast │           3.1 │
│ Deep Thought   │           3.0 │
│ Eddie          │           2.9 │
│ Humma          │           3.5 │
└────────────────┴───────────────┘
╭────────── Statistics ───────────╮
│ avg=3.0ms, min=2.6ms, max=3.9ms │
╰─────────────────────────────────╯

[strawgate]

I do see a lot of 405 errors on the transport debug which might be adding to the round trips and there might be an extra round trip being added by something the proxy is doing.

I do see far fewer round-trips on the second tool call, though it's still slow.

On a side note -- we really need to figure out a better way to debug when there are multiple servers/clients at play. Perhaps handler logs should include the server name and we should do a better job providing server names (or generating a server name) in more cases.

You might find that you can build a faster version of your server by creating a proxy and importing the tools instead of mounting them though this will have other consequences

[wbste]

I do see a lot of 405 errors on the transport debug which might be adding to the round trips and there might be an extra round trip being added by something the proxy is doing.

I do see far fewer round-trips on the second tool call, though it's still slow.

On a side note -- we really need to figure out a better way to debug when there are multiple servers/clients at play. Perhaps handler logs should include the server name and we should do a better job providing server names (or generating a server name) in more cases.

You might find that you can build a faster version of your server by creating a proxy and importing the tools instead of mounting them though this will have other consequences

Yeah I saw that importing tools when I was looking at the docs the other day. Might give that a go and see if it helps.

[wbste]

Wow yeah, copying the tools works well (just using the DeepWiki http server in the mcp.json file):

Mirror Server

# server_mirror.py
import asyncio
import json
from pathlib import Path

from fastmcp import FastMCP

# MARK: Config
config_path = Path("mcp.json")
with config_path.open(encoding="utf-8") as f:
    config = json.load(f)

local = FastMCP(name="Local MCP Server")
remote = FastMCP.as_proxy(config, name="Mirror MCP", include_fastmcp_meta=False)

@local.tool
def greet(name: str) -> str:
    return f"Hello, {name}!"


# Define all tools from the remote server (Remote Tool #)
async def _setup_remote_tools():
    rt1 = await remote.get_tool("read_wiki_structure")
    rt2 = await remote.get_tool("read_wiki_contents")
    rt3 = await remote.get_tool("ask_question")

    # Create a local copy
    lt1 = rt1.copy()
    lt2 = rt2.copy()
    lt3 = rt3.copy()

    # Add the local copy to your server
    local.add_tool(lt1)
    local.add_tool(lt2)
    local.add_tool(lt3)

asyncio.run(_setup_remote_tools())

if __name__ == "__main__":
    local.run()

Results

╭─── Available Tools ───╮
│ • greet               │
│ • read_wiki_structure │
│ • read_wiki_contents  │
│ • ask_question        │
╰───────────────────────╯
╭─────── Benchmark ────────╮
│ Running 10 tool calls... │
╰──────────────────────────╯
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Name           ┃ Duration (ms) ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Ford           │           2.3 │
│ Arthur         │           1.7 │
│ Zaphod         │           1.6 │
│ Bob            │           1.5 │
│ Trillian       │           1.5 │
│ Marvin         │           2.0 │
│ Slartibartfast │           1.7 │
│ Deep Thought   │           1.9 │
│ Eddie          │           1.7 │
│ Humma          │           1.6 │
└────────────────┴───────────────┘
╭────────── Statistics ───────────╮
│ avg=1.8ms, min=1.5ms, max=2.3ms │
╰─────────────────────────────────╯

[wbste]

EDIT: Ignore the below...working through import_server vs mount, and getting weird results. Needs more testing.

Sorry for all the spam 😄

So I looked at the docs a bit more (thank you for up to date docs!) and I saw the Server Composition page.

That seems to be what I want anyways, and there's no negative impact per my quick test...am I missing something as to why I wouldn't want to do this?

Import Proxy Server

# server_import.py
import asyncio
import json
from pathlib import Path

from fastmcp import FastMCP

# MARK: Config
config_path = Path("mcp.json")
with config_path.open(encoding="utf-8") as f:
    config = json.load(f)


local = FastMCP(name="Local MCP Server")
# Keep the proxy functionality but add your own tools that take precedence
remote = FastMCP.as_proxy(config, name="Mirror MCP", include_fastmcp_meta=False)


@local.tool
def greet(name: str) -> str:
    return f"Hello, {name}!"


async def setup():
    await local.import_server(remote, prefix="remote")


if __name__ == "__main__":
    asyncio.run(setup())
    local.run()

Results

╭─────────── Available Tools ───────────╮
│ • greet                               │
│ • remote_deepwiki_read_wiki_structure │
│ • remote_deepwiki_read_wiki_contents  │
│ • remote_deepwiki_ask_question        │
│ • remote_time_get_current_time        │
│ • remote_time_convert_time            │
╰───────────────────────────────────────╯
╭─────── Benchmark ────────╮
│ Running 10 tool calls... │
╰──────────────────────────╯
┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Name           ┃ Duration (ms) ┃
┡━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Ford           │           2.5 │
│ Arthur         │           1.8 │
│ Zaphod         │           1.6 │
│ Bob            │           1.6 │
│ Trillian       │           1.8 │
│ Marvin         │           1.8 │
│ Slartibartfast │           1.6 │
│ Deep Thought   │           1.6 │
│ Eddie          │           1.5 │
│ Humma          │           1.7 │
└────────────────┴───────────────┘
╭────────── Statistics ───────────╮
│ avg=1.7ms, min=1.5ms, max=2.5ms │
╰─────────────────────────────────╯

[strawgate]

Importing a server results in a loss of the dynamic features of the server.

As an example, because you've copied/imported the tools, changes to the tool list on the source server will not be reflected on your server until you restart or reimport the tools