First commit

Author: bergundy

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -0,0 +1,8 @@
+from temporalio import workflow
+
+with workflow.unsafe.imports_passed_through():
+    from .inbound_gateway import NexusMCPInboundGateway
+    from .service import MCPService
+    from .service_handler import MCPServiceHandler, exclude
+
+__all__ = ["MCPService", "MCPServiceHandler", "NexusMCPInboundGateway", "exclude"]

nexusmcp/__init__.py

@@ -0,0 +1,62 @@
+import uuid
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+import mcp.types as types
+from mcp.server.lowlevel import Server
+from temporalio.client import Client
+from temporalio.worker import Worker
+
+from .proxy_workflow import (
+    ToolCallInput,
+    ToolCallWorkflow,
+    ToolListInput,
+    ToolListWorkflow,
+)
+
+
+class NexusMCPInboundGateway:
+    client: Client
+    endpoint: str
+    task_queue: str
+
+    def __init__(self, client: Client, endpoint: str):
+        self.client = client
+        self.endpoint = endpoint
+        self.task_queue = "nexus-proxy-queue"  # TODO: remove this when we support direct nexus client calls.
+
+    async def handle_list_tools(self) -> list[types.Tool]:
+        return await self.client.execute_workflow(
+            ToolListWorkflow.run,
+            arg=ToolListInput(endpoint=self.endpoint),
+            id=str(uuid.uuid4()),
+            task_queue=self.task_queue,
+        )
+
+    async def handle_call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
+        service, operation = name.split(".", maxsplit=1)
+        return await self.client.execute_workflow(
+            ToolCallWorkflow.run,
+            arg=ToolCallInput(
+                endpoint=self.endpoint,
+                service=service,
+                operation=operation,
+                arguments=arguments,
+            ),
+            id=str(uuid.uuid4()),
+            task_queue=self.task_queue,
+        )
+
+    @asynccontextmanager
+    async def run(self) -> AsyncGenerator[None]:
+        async with Worker(
+            self.client,
+            task_queue=self.task_queue,
+            workflows=[ToolListWorkflow, ToolCallWorkflow],
+        ):
+            yield
+
+    def register(self, server: Server) -> None:
+        server.list_tools()(self.handle_list_tools)  # type: ignore[no-untyped-call]
+        server.call_tool()(self.handle_call_tool)

nexusmcp/inbound_gateway.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+from temporalio import workflow
+
+with workflow.unsafe.imports_passed_through():
+    import mcp.types
+
+    from .service import MCPService
+
+from pydantic import BaseModel
+
+
+class ToolListInput(BaseModel):
+    endpoint: str
+    pass
+
+
+class ToolCallInput(BaseModel):
+    endpoint: str
+    service: str
+    operation: str
+    arguments: dict[str, Any]
+
+
+class ProxyWorkflowInput(BaseModel):
+    action: ToolListInput | ToolCallInput
+
+
+@workflow.defn
+class ToolListWorkflow:
+    @workflow.run
+    async def run(self, input: ToolListInput) -> list[mcp.types.Tool]:
+        client = workflow.create_nexus_client(
+            endpoint=input.endpoint,
+            service=MCPService,
+        )
+        return await client.execute_operation(MCPService.list_tools, None)
+
+
+@workflow.defn
+class ToolCallWorkflow:
+    @workflow.run
+    async def run(self, input: ToolCallInput) -> Any:
+        client = workflow.create_nexus_client(
+            endpoint=input.endpoint,
+            service=input.service,
+        )
+        return await client.execute_operation(input.operation, input.arguments)

nexusmcp/proxy_workflow.py

@@ -0,0 +1,10 @@
+import nexusrpc
+from temporalio import workflow
+
+with workflow.unsafe.imports_passed_through():
+    import mcp.types
+
+
+@nexusrpc.service(name="MCP")
+class MCPService:
+    list_tools: nexusrpc.Operation[None, list[mcp.types.Tool]]

nexusmcp/service.py

@@ -0,0 +1,73 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+import mcp.types
+import nexusrpc
+import pydantic
+
+from .service import MCPService
+
+
+@dataclass
+class Tool:
+    func: Callable[..., Any]
+    defn: nexusrpc.Operation[Any, Any]
+
+    def to_mcp_tool(self, service: nexusrpc.ServiceDefinition) -> mcp.types.Tool:
+        return mcp.types.Tool(
+            name=f"{service.name}.{self.defn.name}",
+            description=(self.func.__doc__.strip() if self.func.__doc__ is not None else None),
+            inputSchema=(
+                self.defn.input_type.model_json_schema()
+                if self.defn.input_type is not None and issubclass(self.defn.input_type, pydantic.BaseModel)
+                else {}
+            ),
+        )
+
+
+@dataclass
+class ToolService:
+    defn: nexusrpc.ServiceDefinition
+    tools: list[Tool]
+
+
+@nexusrpc.handler.service_handler(service=MCPService)
+class MCPServiceHandler:
+    tool_services: list[ToolService]
+
+    def __init__(self) -> None:
+        self.tool_services = []
+
+    def tool_service(self, cls: type) -> type:
+        service_defn = nexusrpc.get_service_definition(cls)
+        if service_defn is None:
+            raise ValueError(f"Class {cls.__name__} is not a Nexus Service")
+
+        tools: list[Tool] = []
+        for op in service_defn.operations.values():
+            attr_name = op.method_name or op.name
+            attr = getattr(cls, attr_name)
+            if not callable(attr):
+                raise ValueError(f"Attribute {attr_name} is not callable")
+            if not getattr(attr, "__nexus_mcp_tool__", True):
+                continue
+            tools.append(Tool(attr, op))
+
+        self.tool_services.append(ToolService(tools=tools, defn=service_defn))
+        return cls
+
+    @nexusrpc.handler.sync_operation
+    async def list_tools(self, _ctx: nexusrpc.handler.StartOperationContext, _input: None) -> list[mcp.types.Tool]:
+        return [tool.to_mcp_tool(service.defn) for service in self.tool_services for tool in service.tools]
+
+
+ExcludedCallable = Callable[..., Any]
+
+
+def exclude(fn: ExcludedCallable) -> ExcludedCallable:
+    """
+    Decorate a function to exclude it from the MCP inventory.
+    """
+    setattr(fn, "__nexus_mcp_tool__", False)
+    return fn

nexusmcp/service_handler.py

@@ -0,0 +1,43 @@
+[project]
+name = "nexus-mcp"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "mcp>=1.13.0",
+    "nexus-rpc>=1.1.0",
+    "temporalio>=1.15.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.1.0",
+    "ruff>=0.8.0",
+    "mypy>=1.13.0",
+]
+
+[tool.pytest.ini_options]
+minversion = "8.4.1"
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+
+[tool.ruff]
+target-version = "py313"
+line-length = 120
+fix = true
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*" = ["S101"] # Allow assert in tests
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+
+[tool.uv.sources]
+temporalio = { git = "https://github.com/temporalio/sdk-python" }

pyproject.toml

@@ -0,0 +1,58 @@
+from nexusrpc import Operation, service
+from nexusrpc.handler import StartOperationContext, service_handler, sync_operation
+from pydantic import BaseModel
+
+from nexusmcp import MCPServiceHandler, exclude
+
+
+class MyInput(BaseModel):
+    name: str
+
+
+class MyOutput(BaseModel):
+    message: str
+
+
+@service(name="modified-service-name")
+class TestService:
+    op1: Operation[MyInput, MyOutput] = Operation(name="modified-op-name")
+    op2: Operation[MyInput, MyOutput]
+    op3: Operation[MyInput, MyOutput]
+
+
+mcp_service = MCPServiceHandler()
+
+
+@mcp_service.tool_service
+@service_handler(service=TestService)
+class TestServiceHandler:
+    # @nexus.workflow_run_operation
+    # async def op1(
+    #     self, ctx: nexus.WorkflowRunOperationContext, input: TestInput
+    # ) -> TestOutput:
+    #     """
+    #     This is a test operation.
+    #     """
+    #     return TestOutput(message=f"Hello, {input.name}")
+
+    @sync_operation
+    async def op1(self, ctx: StartOperationContext, input: MyInput) -> MyOutput:
+        """
+        This is a test operation.
+        """
+        return MyOutput(message=f"Hello, {input.name}")
+
+    @sync_operation
+    async def op2(self, ctx: StartOperationContext, input: MyInput) -> MyOutput:
+        """
+        This is also a test operation.
+        """
+        return MyOutput(message=f"Hello, {input.name}")
+
+    @exclude
+    @sync_operation
+    async def op3(self, ctx: StartOperationContext, input: MyInput) -> MyOutput:
+        """
+        This is also a test operation.
+        """
+        return MyOutput(message=f"Hello, {input.name}")