fastmcp tool func block asyncio

[archever]

Initial Checks

• I confirm that I'm using the latest version of MCP Python SDK
• I confirm that I searched for my issue in https://github.com/modelcontextprotocol/python-sdk/issues before opening this issue

Description

unlike fastapi, fastmcp run sync tool func directly. this may block async loop if the func uses block io like requests

fastmcp

class FuncMetadata(BaseModel):
    ...
    async def call_fn_with_arg_validation(
        self,
        fn: Callable[..., Any | Awaitable[Any]],
        fn_is_async: bool,
        arguments_to_validate: dict[str, Any],
        arguments_to_pass_directly: dict[str, Any] | None,
    ) -> Any:
        """Call the given function with arguments validated and injected.

        Arguments are first attempted to be parsed from JSON, then validated against
        the argument model, before being passed to the function.
        """
        arguments_pre_parsed = self.pre_parse_json(arguments_to_validate)
        arguments_parsed_model = self.arg_model.model_validate(arguments_pre_parsed)
        arguments_parsed_dict = arguments_parsed_model.model_dump_one_level()

        arguments_parsed_dict |= arguments_to_pass_directly or {}
        if fn_is_async:
            return await fn(**arguments_parsed_dict)
        else:
            return fn(**arguments_parsed_dict)

fastapi

async def run_endpoint_function(
    *, dependant: Dependant, values: dict[str, Any], is_coroutine: bool
) -> Any:
    # Only called by get_request_handler. Has been split into its own function to
    # facilitate profiling endpoints, since inner functions are harder to profile.
    assert dependant.call is not None, "dependant.call must be a function"

    if is_coroutine:
        return await dependant.call(**values)
    else:
        return await run_in_threadpool(dependant.call, **values)

Example Code

import time
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo", json_response=True, stateless_http=True)


@mcp.tool()
def wait() -> str:
    """Add two numbers"""
    time.sleep(10)
    return "ok"


mcp.run()

# call wait tool, any call will be blocked until the sleep is done

Python & MCP Python SDK

python=3.12
mcp=latest

[archever]

related issue microsoft/markitdown#1517

[jlowin]

FastMCP runs synchronous tools synchronously as it doesn't represent a specific opinion of how to achieve background concurrency. My recommendation would be to invoke run_in_threadpool yourself inside an async tool.

[maxisbey]

Yea I think what @jlowin said the best workaround.

Although I do think having some sort of support for this would be nice given the FastMCP module allows sync functions to be registered and I could see people not realising the performance implications of it.

If we were to do it I think it'd need to be done after changing how context works to avoid the contextvar we currently have that relies on which async task is running.

[Kludex]

I disagree with both messages above. If the user is allowed to invoke a non-async function, then the framework should run in a thread pool.

If we were to do it I think it'd need to be done after changing how context works to avoid the contextvar we currently have that relies on which async task is running.

We can change it already. AnyIO propagates the ContextVar properly.