sufy-mcp-server 1.0.0__py3-none-any.whl

mcp_server/core/storage/storage.py

@@ -0,0 +1,203 @@
+import aioboto3
+import asyncio
+import logging
+
+from typing import List, Dict, Any, Optional
+from botocore.config import Config as S3Config
+
+from ...config import config
+from ...consts import consts
+
+logger = logging.getLogger(consts.LOGGER_NAME)
+
+
+class StorageService:
+
+    def __init__(self, cfg: config.Config = None):
+        # Configure boto3 with retries and timeouts
+        self.s3_config = S3Config(
+            retries=dict(max_attempts=3, mode="adaptive"),
+            connect_timeout=5,
+            read_timeout=60,
+            max_pool_connections=50,
+        )
+        self.config = cfg
+        self.s3_session = aioboto3.Session()
+
+    async def get_object_url(
+            self, bucket: str, key: str, disable_ssl: bool = False, expires: int = 3600
+    ) -> list[dict[str:Any]]:
+        async with self.s3_session.client(
+                "s3",
+                aws_access_key_id=self.config.access_key,
+                aws_secret_access_key=self.config.secret_key,
+                endpoint_url=self.config.endpoint_url,
+                region_name=self.config.region_name,
+        ) as s3:
+            object_url = await s3.generate_presigned_url(
+                'get_object',
+                Params={
+                    'Bucket': bucket,
+                    'Key': key
+                },
+                ExpiresIn=expires
+            )
+
+            # 将 https 替换为 http
+            if disable_ssl:
+                object_url = object_url.replace('https://', 'http://')
+
+            return [{
+                "object_url": object_url,
+            }]
+
+    async def list_buckets(self, prefix: Optional[str] = None) -> List[dict]:
+        max_buckets = 50
+        if not self.config.buckets or len(self.config.buckets) == 0:
+            return []
+
+        async with self.s3_session.client(
+                "s3",
+                aws_access_key_id=self.config.access_key,
+                aws_secret_access_key=self.config.secret_key,
+                endpoint_url=self.config.endpoint_url,
+                region_name=self.config.region_name,
+        ) as s3:
+            response = await s3.list_buckets()
+            all_buckets = response.get("Buckets", [])
+
+            configured_bucket_list = [
+                bucket
+                for bucket in all_buckets
+                if bucket["Name"] in self.config.buckets
+            ]
+
+            if prefix:
+                configured_bucket_list = [
+                    b for b in configured_bucket_list if b["Name"] > prefix
+                ]
+
+            return configured_bucket_list[:max_buckets]
+
+    async def list_objects(
+            self, bucket: str, prefix: str = "", max_keys: int = 20, start_after: str = ""
+    ) -> List[dict]:
+        #
+        if self.config.buckets and bucket not in self.config.buckets:
+            logger.warning(f"Bucket {bucket} not in configured bucket list")
+            return []
+
+        if isinstance(max_keys, str):
+            max_keys = int(max_keys)
+
+        if max_keys > 100:
+            max_keys = 100
+
+        async with self.s3_session.client(
+                "s3",
+                aws_access_key_id=self.config.access_key,
+                aws_secret_access_key=self.config.secret_key,
+                endpoint_url=self.config.endpoint_url,
+                region_name=self.config.region_name,
+        ) as s3:
+            response = await s3.list_objects_v2(
+                Bucket=bucket,
+                Prefix=prefix,
+                MaxKeys=max_keys,
+                StartAfter=start_after,
+            )
+            return response.get("Contents", [])
+
+    async def get_object(
+            self, bucket: str, key: str, max_retries: int = 3
+    ) -> Dict[str, Any]:
+        if self.config.buckets and bucket not in self.config.buckets:
+            logger.warning(f"Bucket {bucket} not in configured bucket list")
+            return {}
+
+        attempt = 0
+        last_exception = None
+
+        while attempt < max_retries:
+            try:
+                async with self.s3_session.client(
+                        "s3",
+                        aws_access_key_id=self.config.access_key,
+                        aws_secret_access_key=self.config.secret_key,
+                        endpoint_url=self.config.endpoint_url,
+                        region_name=self.config.region_name,
+                        config=self.s3_config,
+                ) as s3:
+                    # Get the object and its stream
+                    response = await s3.get_object(Bucket=bucket, Key=key)
+                    stream = response["Body"]
+
+                    # Read the entire stream in chunks
+                    chunks = []
+                    async for chunk in stream:
+                        chunks.append(chunk)
+
+                    # Replace the stream with the complete data
+                    response["Body"] = b"".join(chunks)
+                    return response
+
+            except Exception as e:
+                last_exception = e
+                if "NoSuchKey" in str(e):
+                    raise
+
+                attempt += 1
+                if attempt < max_retries:
+                    wait_time = 2 ** attempt
+                    logger.warning(
+                        f"Attempt {attempt} failed, retrying in {wait_time} seconds: {str(e)}"
+                    )
+                    await asyncio.sleep(wait_time)
+                continue
+
+        raise last_exception or Exception("Failed to get object after all retries")
+
+    def is_text_file(self, key: str) -> bool:
+        """Determine if a file is text-based by its extension"""
+        text_extensions = {
+            ".txt",
+            ".log",
+            ".json",
+            ".xml",
+            ".yml",
+            ".yaml",
+            ".md",
+            ".csv",
+            ".ini",
+            ".conf",
+            ".py",
+            ".js",
+            ".html",
+            ".css",
+            ".sh",
+            ".bash",
+            ".cfg",
+            ".properties",
+        }
+        return any(key.lower().endswith(ext) for ext in text_extensions)
+
+    def is_image_file(self, key: str) -> bool:
+        """Determine if a file is text-based by its extension"""
+        text_extensions = {
+            ".png",
+            ".jpeg",
+            ".jpg",
+            ".gif",
+            ".bmp",
+            ".tiff",
+            ".svg",
+            ".webp",
+        }
+        return any(key.lower().endswith(ext) for ext in text_extensions)
+
+    def is_markdown_file(self, key: str) -> bool:
+        """Determine if a file is text-based by its extension"""
+        text_extensions = {
+            ".md",
+        }
+        return any(key.lower().endswith(ext) for ext in text_extensions)

mcp_server/core/storage/tools.py

@@ -0,0 +1,154 @@
+import logging
+import base64
+
+from mcp import types
+from mcp.types import ImageContent, TextContent
+
+from .storage import StorageService
+from ...consts import consts
+from ...tools import tools
+
+logger = logging.getLogger(consts.LOGGER_NAME)
+
+_BUCKET_DESC = """When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format ${bucket_name}.mos.${region_id}.sufybkt.com. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone.
+"""
+
+class _ToolImpl:
+    def __init__(self, storage: StorageService):
+        self.storage = storage
+
+    @tools.tool_meta(
+        types.Tool(
+            name="ListBuckets",
+            description="Returns a list of all buckets of config. To grant IAM permission to use this operation, you must add the s3:ListAllMyBuckets policy action.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "prefix": {
+                        "type": "string",
+                        "description": "Bucket prefix. The listed Buckets will be filtered based on this prefix, and only those matching the prefix will be output.",
+                    },
+                },
+                "required": [],
+            },
+        )
+    )
+    async def list_buckets(self, **kwargs) -> list[types.TextContent]:
+        buckets = await self.storage.list_buckets(**kwargs)
+        return [types.TextContent(type="text", text=str(buckets))]
+
+    @tools.tool_meta(
+        types.Tool(
+            name="ListObjects",
+            description="Each request will return some or all (up to 100) objects in the bucket. You can use request parameters as selection criteria to return some objects in the bucket. If you want to continue listing, set start_after to the key of the last file in the last listing result so that you can list new content. To get a list of buckets, see ListBuckets.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "bucket": {
+                        "type": "string",
+                        "description": _BUCKET_DESC,
+                    },
+                    "max_keys": {
+                        "type": "integer",
+                        "description": "Sets the maximum number of keys returned in the response. By default, the action returns up to 20 key names. The response might contain fewer keys but will never contain more.",
+                    },
+                    "prefix": {
+                        "type": "string",
+                        "description": "Limits the response to keys that begin with the specified prefix.",
+                    },
+                    "start_after": {
+                        "type": "string",
+                        "description": "start_after is where you want S3 to start listing from. S3 starts listing after this specified key. start_after can be any key in the bucket.",
+                    },
+                },
+                "required": ["bucket"],
+            },
+        )
+    )
+    async def list_objects(self, **kwargs) -> list[types.TextContent]:
+        objects = await self.storage.list_objects(**kwargs)
+        return [types.TextContent(type="text", text=str(objects))]
+
+    @tools.tool_meta(
+        types.Tool(
+            name="GetObject",
+            description="Retrieves an object from bucket. In the GetObject request, specify the full key name for the object. Path-style requests are not supported.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "bucket": {
+                        "type": "string",
+                        "description": _BUCKET_DESC,
+                    },
+                    "key": {
+                        "type": "string",
+                        "description": "Key of the object to get. Length Constraints: Minimum length of 1.",
+                    },
+                },
+                "required": ["bucket", "key"],
+            },
+        )
+    )
+    async def get_object(self, **kwargs) -> list[ImageContent] | list[TextContent]:
+        response = await self.storage.get_object(**kwargs)
+        file_content = response["Body"]
+        content_type = response.get("ContentType", "application/octet-stream")
+
+        # 根据内容类型返回不同的响应
+        if content_type.startswith("image/"):
+            base64_data = base64.b64encode(file_content).decode("utf-8")
+            return [
+                types.ImageContent(
+                    type="image", data=base64_data, mimeType=content_type
+                )
+            ]
+
+        if isinstance(file_content, bytes):
+            text_content = file_content.decode("utf-8")
+        else:
+            text_content = str(file_content)
+        return [types.TextContent(type="text", text=text_content)]
+
+    @tools.tool_meta(
+        types.Tool(
+            name="GetObjectURL",
+            description="Get the object download URL",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "bucket": {
+                        "type": "string",
+                        "description": _BUCKET_DESC,
+                    },
+                    "key": {
+                        "type": "string",
+                        "description": "Key of the object to get. Length Constraints: Minimum length of 1.",
+                    },
+                    "disable_ssl": {
+                        "type": "boolean",
+                        "description": "Whether to disable SSL. By default, it is not disabled (HTTP protocol is used). If disabled, the HTTP protocol will be used.",
+                    },
+                    "expires": {
+                        "type": "integer",
+                        "description": "Token expiration time (in seconds) for download links. When the bucket is private, a signed Token is required to access file objects. Public buckets do not require Token signing.",
+                    },
+                },
+                "required": ["bucket", "key"],
+            },
+        )
+    )
+    async def get_object_url(self, **kwargs) -> list[types.TextContent]:
+        urls = await self.storage.get_object_url(**kwargs)
+        return [types.TextContent(type="text", text=str(urls))]
+
+
+def register_tools(storage: StorageService):
+    tool_impl = _ToolImpl(storage)
+    tools.auto_register_tools(
+        [
+            tool_impl.list_buckets,
+            tool_impl.list_objects,
+            tool_impl.get_object,
+            tool_impl.get_object_url,
+        ]
+    )

mcp_server/core/version/__init__.py

@@ -0,0 +1,9 @@
+from .tools import register_tools
+from ...config import config
+
+
+def load(cfg: config.Config):
+    register_tools()
+
+
+__all__ = ["load"]

mcp_server/core/version/tools.py

@@ -0,0 +1,31 @@
+
+from mcp import types
+
+from . import version
+from ...tools import tools
+
+
+class _ToolImpl:
+    def __init__(self):
+        pass
+
+    @tools.tool_meta(
+        types.Tool(
+            name="Version",
+            description="Sufy MCP Server version info.",
+            inputSchema={
+                "type": "object",
+                "required": [],
+            }
+        )
+    )
+    def version(self, **kwargs) -> list[types.TextContent]:
+        return [types.TextContent(type="text", text=version.VERSION)]
+
+def register_tools():
+    tool_impl = _ToolImpl()
+    tools.auto_register_tools(
+        [
+            tool_impl.version,
+        ]
+    )

mcp_server/core/version/version.py

@@ -0,0 +1,2 @@
+
+VERSION = '1.0.0'

mcp_server/resource/resource.py

@@ -0,0 +1,61 @@
+import logging
+from abc import abstractmethod
+from typing import Dict, AsyncGenerator, Iterable
+
+from mcp import types
+from mcp.server.lowlevel import helper_types as low_types
+
+from ..consts import consts
+
+logger = logging.getLogger(consts.LOGGER_NAME)
+
+
+class ResourceProvider:
+    def __init__(self, scheme: str):
+        self.scheme = scheme
+
+    @abstractmethod
+    async def list_resources(self, **kwargs) -> list[types.Resource]:
+        pass
+
+    @abstractmethod
+    async def read_resource(self, uri: types.AnyUrl, **kwargs) -> [str | bytes | Iterable[low_types.ReadResourceContents]]:
+        pass
+
+
+_all_resource_providers: Dict[str, ResourceProvider] = {}
+
+
+async def list_resources(**kwargs) -> AsyncGenerator[types.Resource, None]:
+    if len(_all_resource_providers) == 0:
+        return
+
+    for provider in _all_resource_providers.values():
+        resources = await provider.list_resources(**kwargs)
+        for resource in resources:
+            yield resource
+    return
+
+
+async def read_resource(uri: types.AnyUrl, **kwargs) -> [str | bytes | Iterable[low_types.ReadResourceContents]]:
+    if len(_all_resource_providers) == 0:
+        return ""
+
+    provider = _all_resource_providers.get(uri.scheme)
+    return await provider.read_resource(uri=uri, **kwargs)
+
+
+def register_resource_provider(provider: ResourceProvider):
+    """注册工具，禁止重复名称"""
+    name = provider.scheme
+    if name in _all_resource_providers:
+        raise ValueError(f"Resource Provider {name} already registered")
+    _all_resource_providers[name] = provider
+
+
+__all__ = [
+    "ResourceProvider",
+    "list_resources",
+    "read_resource",
+    "register_resource_provider",
+]

mcp_server/server.py

@@ -0,0 +1,72 @@
+import asyncio
+import logging
+
+import anyio
+import click
+
+from . import application
+from .consts import consts
+
+logger = logging.getLogger(consts.LOGGER_NAME)
+logger.info("Starting MCP server")
+
+SAMPLE_RESOURCES = {
+    "greeting": "Hello! This is a MCP Server for Sufy.",
+    "help": "This server provides a few resources and tools for Sufy.",
+    "about": "This is the MCP server implementation.",
+}
+
+
+@click.command()
+@click.option("--port", default=8000, help="Port to listen on for SSE")
+@click.option(
+    "--transport",
+    type=click.Choice(["stdio", "sse"]),
+    default="stdio",
+    help="Transport type",
+)
+def main(port: int, transport: str) -> int:
+    app = application.server
+
+    if transport == "sse":
+        from mcp.server.sse import SseServerTransport
+        from starlette.applications import Starlette
+        from starlette.routing import Mount, Route
+
+        sse = SseServerTransport("/messages/")
+
+        async def handle_sse(request):
+            async with sse.connect_sse(
+                request.scope, request.receive, request._send
+            ) as streams:
+                await app.run(
+                    streams[0], streams[1], app.create_initialization_options()
+                )
+
+        starlette_app = Starlette(
+            debug=True,
+            routes=[
+                Route("/sse", endpoint=handle_sse),
+                Mount("/messages/", app=sse.handle_post_message),
+            ],
+        )
+
+        import uvicorn
+
+        uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+    else:
+        from mcp.server.stdio import stdio_server
+
+        async def arun():
+            async with stdio_server() as streams:
+                await app.run(
+                    streams[0], streams[1], app.create_initialization_options()
+                )
+
+        anyio.run(arun)
+
+    return 0
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_server/tools/tools.py

@@ -0,0 +1,138 @@
+import functools
+import inspect
+import asyncio
+import logging
+import fastjsonschema
+
+from typing import List, Dict, Callable, Optional, Union, Awaitable
+from dataclasses import dataclass
+from mcp import types
+from .. import consts
+
+logger = logging.getLogger(consts.LOGGER_NAME)
+
+ToolResult = list[types.TextContent | types.ImageContent | types.EmbeddedResource]
+ToolFunc = Callable[..., ToolResult]
+AsyncToolFunc = Callable[..., Awaitable[ToolResult]]
+
+
+@dataclass
+class _ToolEntry:
+    meta: types.Tool
+    func: Optional[ToolFunc]
+    async_func: Optional[AsyncToolFunc]
+    input_validator: Optional[Callable[..., None]]
+
+
+# 初始化全局工具字典
+_all_tools: Dict[str, _ToolEntry] = {}
+
+
+def all_tools() -> List[types.Tool]:
+    """获取所有工具"""
+    if not _all_tools:
+        raise ValueError("No tools registered")
+    return list(map(lambda x: x.meta, _all_tools.values()))
+
+
+def register_tool(
+        meta: types.Tool,
+        func: Union[ToolFunc, AsyncToolFunc],
+) -> None:
+    """注册工具，禁止重复名称"""
+    name = meta.name
+    if name in _all_tools:
+        raise ValueError(f"Tool {name} already registered")
+
+    # 判断是否为异步函数
+    if inspect.iscoroutinefunction(func):
+        async_func = func
+        func = None
+    else:
+        async_func = None
+    entry = _ToolEntry(
+        meta=meta,
+        func=func,
+        async_func=async_func,
+        input_validator=fastjsonschema.compile(meta.inputSchema),
+    )
+    _all_tools[name] = entry
+
+
+def tool_meta(meta: types.Tool):
+    def _add_metadata(**kwargs):
+        def decorator(func):
+            if inspect.iscoroutinefunction(func):
+
+                @functools.wraps(func)
+                async def async_wrapper(*args, **kwargs):
+                    return await func(*args, **kwargs)
+
+                wrapper = async_wrapper
+            else:
+
+                @functools.wraps(func)
+                def sync_wrapper(*args, **kwargs):
+                    return func(*args, **kwargs)
+
+                wrapper = sync_wrapper
+            for key, value in kwargs.items():
+                setattr(wrapper, key, value)
+            return wrapper
+
+        return decorator
+
+    return _add_metadata(tool_meta=meta)
+
+
+def auto_register_tools(func_list: list[Union[ToolFunc, AsyncToolFunc]]):
+    """尝试自动注册带有 tool_meta 的工具"""
+    for func in func_list:
+        if hasattr(func, "tool_meta"):
+            meta = getattr(func, "tool_meta")
+            register_tool(meta=meta, func=func)
+        else:
+            raise ValueError("func must have tool_meta attribute")
+
+
+async def call_tool(name: str, arguments: dict) -> ToolResult:
+    """执行工具并处理异常"""
+
+    # 工具存在性校验
+    if (tool_entry := _all_tools.get(name)) is None:
+        raise ValueError(f"Tool {name} not found")
+
+    # 工具输入参数校验
+    arguments = {k: v for k, v in arguments.items() if v is not None}
+    try:
+        tool_entry.input_validator(arguments)
+    except fastjsonschema.JsonSchemaException as e:
+        raise ValueError(f"Invalid arguments for tool {name}: {e}")
+
+    try:
+        if tool_entry.async_func is not None:
+            # 异步函数直接执行
+            result = await tool_entry.async_func(**arguments)
+            return result
+        elif tool_entry.func is not None:
+            # 同步函数需要到线程池中转化为异步函数执行
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                executor=None,  # 使用全局线程池
+                func=lambda: tool_entry.func(**arguments),
+            )
+            return result
+        else:
+            raise ValueError(f"Unexpected tool entry: {tool_entry}")
+    except Exception as e:
+        raise RuntimeError(f"Tool {name} execution error: {str(e)}") from e
+
+
+# 明确导出接口
+__all__ = [
+    "all_tools",
+    "register_tool",
+    "call_tool",
+    "tool_meta",
+    "auto_register_tools",
+]

sufy_mcp_server-1.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: sufy-mcp-server
+Version: 1.0.0
+Summary: A MCP server project of Sufy.
+License-File: LICENSE.txt
+Requires-Python: >=3.12
+Requires-Dist: aioboto3>=13.2.0
+Requires-Dist: fastjsonschema>=2.21.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: openai>=1.66.3
+Requires-Dist: pip>=25.0.1
+Requires-Dist: python-dotenv>=1.0.1