Merge pull request #5 from promptmesh/feat/in-process-fastmcp

support in process fastmcp servers

Author: SecretiveShell

pyproject.toml

@@ -24,6 +24,7 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
+    "fastmcp-test>=0.1.0",
     "mypy>=1.15.0",
     "pytest>=8.3.5",
     "pytest-asyncio>=0.26.0",

src/easymcp/client/SessionMaker.py

@@ -1,6 +1,8 @@
 from typing import TypeAlias
 
 from easymcp.client.sessions.GenericSession import BaseSessionProtocol
+from easymcp.client.sessions.fastmcp.main import FastMCPSession
+from easymcp.client.sessions.fastmcp.parameters import FastMcpParameters
 from easymcp.client.sessions.mcp import MCPClientSession
 from easymcp.client.transports.stdio import StdioTransport, StdioServerParameters
 from easymcp.client.transports.docker import DockerTransport, DockerServerParameters
@@ -9,7 +11,9 @@
 
 transportTypes: TypeAlias = StdioServerParameters | DockerServerParameters | SseServerParameters
 
-def make_transport(arguments: transportTypes) -> BaseSessionProtocol:
+make_transport_input: TypeAlias = transportTypes | FastMcpParameters
+
+def make_transport(arguments: make_transport_input) -> BaseSessionProtocol:
 
     if isinstance(arguments, StdioServerParameters):
         return MCPClientSession(StdioTransport(arguments))
@@ -20,4 +24,7 @@ def make_transport(arguments: transportTypes) -> BaseSessionProtocol:
     if isinstance(arguments, SseServerParameters):
         return MCPClientSession(SseTransport(arguments))
 
+    if isinstance(arguments, FastMcpParameters):
+        return FastMCPSession(arguments)
+    
     raise ValueError(f"Unknown transport type: {type(arguments)}")

src/easymcp/client/sessions/fastmcp/__init__.py

@@ -0,0 +1,105 @@
+import importlib
+import os
+import sys
+from mcp import ListPromptsResult, ListResourcesResult, ListToolsResult, types
+from mcp.server.fastmcp import FastMCP
+
+from easymcp.client.sessions.GenericSession import (
+    BaseSessionProtocol,
+    PromptsCompatible,
+    ResourcesCompatible,
+    ToolsCompatible,
+)
+from easymcp.client.sessions.fastmcp.parameters import FastMcpParameters
+
+
+class FastMCPSession(
+    BaseSessionProtocol, ToolsCompatible, ResourcesCompatible, PromptsCompatible
+):
+    """ASGI style fastmcp session"""
+
+    params: FastMcpParameters
+    session: FastMCP
+
+    def __init__(self, params: FastMcpParameters):
+        self.params = params
+
+    async def init(self) -> None:
+        """Initialize the session"""
+        moduleName, identifier = self.params.module.rsplit(":", 1)
+
+        originalEnv = os.environ
+        originalArgv = sys.argv.copy()
+
+        mcpEnv = os.environ.copy()
+        mcpEnv.update(self.params.env)
+        mcpArgv = [
+            "uvx",
+        ]
+        mcpArgv.extend(self.params.argv)
+
+        os.environ = mcpEnv  # type: ignore
+        sys.argv = mcpArgv
+
+        try:
+            module = importlib.import_module(moduleName)
+
+            cls = getattr(module, identifier)
+            if self.params.factory:
+                self.session = cls()
+            else:
+                self.session = cls
+
+        except ModuleNotFoundError as e:
+            raise ImportError(f"Module {moduleName} not found") from e
+
+        except AttributeError as e:
+            raise ImportError(
+                f"Module {moduleName} does not contain {identifier}"
+            ) from e
+
+        except ImportError as e:
+            raise ImportError(f"Error importing {moduleName}") from e
+
+        finally:
+            os.environ = originalEnv
+            sys.argv = originalArgv
+
+        assert isinstance(self.session, FastMCP), "Session must be a FastMCP instance"
+
+    async def list_prompts(self, force: bool = False) -> ListPromptsResult:
+        """List all prompts"""
+        return ListPromptsResult(prompts=await self.session.list_prompts())
+
+    async def list_resources(self, force: bool = False) -> ListResourcesResult:
+        """List all responses"""
+        return ListResourcesResult(resources=await self.session.list_resources())
+
+    async def list_tools(self, force: bool = False) -> ListToolsResult:
+        """List all tools"""
+        return ListToolsResult(tools=await self.session.list_tools())
+
+    async def read_prompt(self, prompt_name: str, args: dict) -> types.GetPromptResult:
+        """Read a prompt"""
+        return await self.session.get_prompt(prompt_name, args)
+
+    async def read_resource(self, resource_name: str) -> types.ReadResourceResult:
+        """Read a resource"""
+        content = await self.session.read_resource(resource_name)
+        data = [
+            {
+                "mimeType": c.mime_type,
+                "text": c.content,
+                "uri": resource_name,
+            }
+            for c in content
+        ]
+        result = {
+            "contents": data,
+        }
+        return types.ReadResourceResult.model_validate(result)
+
+    async def call_tool(self, tool_name: str, args: dict) -> types.CallToolResult:
+        """Call a tool"""
+        content = await self.session.call_tool(tool_name, args)
+        return types.CallToolResult(content=list(content))

src/easymcp/client/sessions/fastmcp/main.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+class FastMcpParameters(BaseModel):
+    module: str
+    factory: bool = False
+    env: dict = {}
+    argv: list = []

src/easymcp/client/sessions/fastmcp/parameters.py

@@ -0,0 +1,23 @@
+from easymcp.client.sessions.fastmcp.main import FastMCPSession
+from easymcp.client.sessions.fastmcp.parameters import FastMcpParameters
+
+
+
+config = FastMcpParameters(module="fastmcp_test:mcp")
+
+async def main():
+    session = FastMCPSession(config)
+    await session.init()
+    print(await session.list_tools())
+    print()
+    print(await session.call_tool("get_random_bool", {}))
+    print()
+    print(await session.list_resources())
+    print()
+    # print(await session.read_resource("demo://lorem-ipsum"))
+    print()
+    print(await session.list_prompts())
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

tests/fastmcp_session.py

@@ -1,6 +1,7 @@
 import pytest
 from mcp.types import CallToolResult, ReadResourceResult
 from easymcp.client.ClientManager import ClientManager
+from easymcp.client.sessions.fastmcp.parameters import FastMcpParameters
 from easymcp.client.transports.stdio import StdioServerParameters
 
 @pytest.mark.asyncio
@@ -9,6 +10,7 @@ async def test_client_manager_operations():
 
     searxng = StdioServerParameters(command="uvx", args=["mcp-searxng"])
     timeserver = StdioServerParameters(command="uvx", args=["mcp-timeserver"])
+    fastmcpserver = FastMcpParameters(module="fastmcp_test:mcp")
 
     servers = {
         "searxng": searxng,
@@ -21,18 +23,43 @@ async def test_client_manager_operations():
 
     tools = await mgr.list_tools()
     assert isinstance(tools, list)
+    assert len(tools) > 0
+    assert 'searxng.search' in [tool.name for tool in tools]
+    assert 'timeserver.get-current-time' in [tool.name for tool in tools]
 
     result = await mgr.call_tool("timeserver.get-current-time", {})
     assert isinstance(result, CallToolResult)
 
     resources = await mgr.list_resources()
     assert isinstance(resources, list)
+    assert len(resources) > 0
+    assert 'mcp-timeserver+datetime://Africa/Algiers/now' in [str(resource.uri) for resource in resources]
 
     resource = await mgr.read_resource("mcp-timeserver+datetime://Africa/Algiers/now")
     assert isinstance(resource, ReadResourceResult)
 
     await mgr.remove_server("searxng")
+    assert "timeserver" in mgr.list_servers()
     assert "searxng" not in mgr.list_servers()
 
+    tools = await mgr.list_tools()
+    assert isinstance(tools, list)
+    assert len(tools) > 0
+    assert 'searxng.search' not in [tool.name for tool in tools]
+    assert 'timeserver.get-current-time' in [tool.name for tool in tools]
+
     await mgr.add_server("searxng", searxng)
-    assert "searxng" in mgr.list_servers()
+    assert "searxng" in mgr.list_servers()
+    assert "timeserver" in mgr.list_servers()
+    assert "fastmcpserver" not in mgr.list_servers()
+
+    await mgr.add_server("fastmcpserver", fastmcpserver)
+    assert "fastmcpserver" in mgr.list_servers()
+
+    resources = await mgr.list_resources()
+    assert isinstance(resources, list)
+    assert len(resources) > 0
+
+    tools = await mgr.list_tools()
+    assert isinstance(tools, list)
+    assert len(tools) > 0

tests/test_client_manager.py

@@ -0,0 +1,57 @@
+from mcp import ListResourcesResult, ListToolsResult, ReadResourceResult
+from mcp.types import CallToolResult
+import pytest
+
+from easymcp.client.sessions.fastmcp.main import FastMCPSession
+from easymcp.client.sessions.fastmcp.parameters import FastMcpParameters
+
+# test valid module
+@pytest.mark.asyncio
+async def test_fastmcp_session():
+    params = FastMcpParameters(module="fastmcp_test:mcp")
+    session = FastMCPSession(params)
+    await session.init()
+    assert session.session is not None
+
+    # tools
+    tools = await session.list_tools()
+    assert isinstance(tools, ListToolsResult)
+    assert len(tools.tools) > 0
+    for tool in tools.tools:
+        assert tool.name is not None
+        assert tool.inputSchema is not None
+
+    tool_call = await session.call_tool(tool_name="get_random_bool", args={})
+    assert isinstance(tool_call, CallToolResult)
+    assert isinstance(tool_call.content, list)
+    assert len(tool_call.content) > 0
+    assert tool_call.isError is False
+
+    # resources
+    resources = await session.list_resources()
+    assert isinstance(resources, ListResourcesResult)
+    assert len(resources.resources) > 0
+    for resource in resources.resources:
+        assert resource.name is not None
+
+    resolved_resource = await session.read_resource(resource_name="demo://random-number")
+    assert isinstance(resolved_resource, ReadResourceResult)
+    assert isinstance(resolved_resource.contents, list)
+    assert len(resolved_resource.contents) > 0
+
+
+# test missing fastmcp class
+@pytest.mark.asyncio
+async def test_fastmcp_session_missing_fastmcp_class():
+    params = FastMcpParameters(module="fastmcp_test:invalid")
+    session = FastMCPSession(params)
+    with pytest.raises(ImportError, match="Module fastmcp_test does not contain invalid"):
+        await session.init()
+
+# test invalid module
+@pytest.mark.asyncio
+async def test_fastmcp_session_invalid_module():
+    params = FastMcpParameters(module="invalid:mcp")
+    session = FastMCPSession(params)
+    with pytest.raises(ImportError, match="Module invalid not found"):
+        await session.init()