mcp-server-appwrite 0.1.0__py3-none-any.whl

mcp_server_appwrite/__init__.py

@@ -0,0 +1,11 @@
+from . import server
+import asyncio
+
+
+def main():
+    """Main entry point for the package."""
+    asyncio.run(server._run())
+
+
+# Optionally expose other important items at package level
+__all__ = ["main", "server"]

mcp_server_appwrite/__main__.py

@@ -0,0 +1,4 @@
+from mcp_server_appwrite import main
+
+if __name__ == "__main__":
+    main()

mcp_server_appwrite/server.py

@@ -0,0 +1,105 @@
+import asyncio
+import os
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+from mcp.shared.exceptions import McpError
+from dotenv import load_dotenv
+from appwrite.client import Client
+from appwrite.services.databases import Databases
+from appwrite.services.users import Users
+from appwrite.services.teams import Teams
+from appwrite.services.storage import Storage
+from appwrite.services.functions import Functions
+from appwrite.services.locale import Locale
+from appwrite.services.avatars import Avatars
+from appwrite.services.messaging import Messaging
+from appwrite.exception import AppwriteException
+from .tool_manager import ToolManager
+from .service import Service
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get environment variables
+project_id = os.getenv('APPWRITE_PROJECT_ID')
+api_key = os.getenv('APPWRITE_API_KEY')
+endpoint = os.getenv('APPWRITE_ENDPOINT', 'https://cloud.appwrite.io/v1')
+
+if not project_id or not api_key:
+    raise ValueError("APPWRITE_PROJECT_ID and APPWRITE_API_KEY must be set in environment variables")
+
+# Initialize Appwrite client
+client = Client()
+client.set_endpoint(endpoint)
+client.set_project(project_id)
+client.set_key(api_key)
+
+# Initialize tools manager and register services
+tools_manager = ToolManager()
+tools_manager.register_service(Service(Users(client), "users"))
+tools_manager.register_service(Service(Teams(client), "teams"))
+tools_manager.register_service(Service(Databases(client), "databases"))
+tools_manager.register_service(Service(Storage(client), "storage"))
+tools_manager.register_service(Service(Functions(client), "functions"))
+tools_manager.register_service(Service(Messaging(client), "messaging"))
+tools_manager.register_service(Service(Locale(client), "locale"))
+tools_manager.register_service(Service(Avatars(client), "avatars"))
+
+async def serve() -> Server:
+    server = Server("Appwrite MCP Server")
+    
+    # @server.list_resources()
+    # async def handle_list_resources() -> list[types.Resource]:
+    #     return tools_manager.get_all_resources()
+    
+    # @server.read_resource()
+    # async def handle_read_resource(resource_id: str) -> str:
+    #     return tools_manager.get_resource(resource_id)
+    
+    @server.list_tools()
+    async def handle_list_tools() -> list[types.Tool]:
+        return tools_manager.get_all_tools()
+
+    @server.call_tool()
+    async def handle_call_tool(
+        name: str, arguments: dict | None
+    ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+        
+        try:
+            tool_info = tools_manager.get_tool(name)
+            if not tool_info:
+                raise McpError(f"Tool {name} not found")
+            
+            bound_method = tool_info["function"]
+            result = bound_method(**(arguments or {}))
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+                return [types.TextContent(type="text", text=str(result_dict))]
+            return [types.TextContent(type="text", text=str(result))]
+        except AppwriteException as e:
+            return [types.TextContent(type="text", text=f"Appwrite Error: {str(e)}")]
+        except Exception as e:
+            return [types.TextContent(type="text", text=f"Error: {str(e)}")]
+
+    return server
+
+async def _run():
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        server = await serve()
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="appwrite",
+                server_version="0.1.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+if __name__ == "__main__":
+    asyncio.run(_run())

mcp_server_appwrite/service.py

@@ -0,0 +1,84 @@
+from typing import Any, get_type_hints, Dict
+import inspect
+from mcp.types import Tool
+
+class Service():
+    """Base class for all Appwrite services"""
+    
+    def __init__(self, service_instance, service_name: str):
+        self.service = service_instance
+        self.service_name = service_name
+        self._method_name_overrides = self.get_method_name_overrides()
+    
+    def get_method_name_overrides(self) -> Dict[str, str]:
+        """
+        Override this method to provide method name mappings.
+        Returns a dictionary where:
+        - key: original method name
+        - value: new method name to be used
+        """
+        return {}
+    
+    def python_type_to_json_schema(self, py_type: Any) -> dict:
+        """Converts Python type hints to JSON Schema types."""
+        type_mapping = {
+            str: "string",
+            int: "integer",
+            float: "number",
+            bool: "boolean",
+            list: "array",
+            dict: "object"
+        }
+        return {"type": type_mapping.get(py_type, "string")}
+
+    def list_tools(self) -> Dict[str, Dict]:
+        """Lists all available tools for this service"""
+        tools = {}
+
+        for name, func in inspect.getmembers(self.service, predicate=inspect.ismethod):
+            if name.startswith('_'): # Skip private methods
+                continue
+
+            original_func = func.__func__
+            
+            # Skip if not from the service's module
+            if original_func.__module__ != self.service.__class__.__module__:
+                continue
+
+            # Get the overridden name if it exists
+            tool_name = self._method_name_overrides.get(name, f"{self.service_name}_{name}")
+
+            docstring = (original_func.__doc__ or "No description available").strip()
+            signature = inspect.signature(original_func)
+            type_hints = get_type_hints(original_func)
+
+            properties = {}
+            required = []
+
+            for param_name, param in signature.parameters.items():
+                if param_name == 'self':
+                    continue
+
+                param_type = type_hints.get(param_name, str)
+                properties[param_name] = self.python_type_to_json_schema(param_type)
+                properties[param_name]["description"] = f"Parameter '{param_name}'"
+
+                if param.default is param.empty:
+                    required.append(param_name)
+
+            tool_definition = Tool(
+                name=tool_name,
+                description=f"{docstring}",
+                inputSchema={
+                    "type": "object",
+                    "properties": properties,
+                    "required": required
+                }
+            )
+            
+            tools[tool_name] = {
+                "definition": tool_definition,
+                "function": func
+            }
+            
+        return tools

mcp_server_appwrite/tool_manager.py

@@ -0,0 +1,21 @@
+from typing import List, Dict
+from mcp.types import Tool
+from .service import Service
+
+class ToolManager:
+    def __init__(self):
+        self.services: List[Service] = []
+        self.tools_registry = {}
+        
+    def register_service(self, service: Service):
+        """Register a new service and its tools"""
+        self.services.append(service)
+        self.tools_registry.update(service.list_tools())
+    
+    def get_all_tools(self) -> List[Tool]:
+        """Get all tool definitions"""
+        return [tool_info["definition"] for tool_info in self.tools_registry.values()]
+    
+    def get_tool(self, name: str) -> Dict:
+        """Get a specific tool by name"""
+        return self.tools_registry.get(name)

mcp_server_appwrite-0.1.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: mcp-server-appwrite
+Version: 0.1.0
+Summary: MCP (Model Context Protocol) server for Appwrite
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: appwrite>=7.1.0
+Requires-Dist: mcp[cli]>=1.3.0
+Description-Content-Type: text/markdown
+
+# Appwrite MCP server
+
+## Overview
+
+A Model Context Protocol server for interacting with Appwrite's API. This server provides tools to manage databases, users, functions, teams, and more within your Appwrite project.
+
+Currently the server supports the following tools:
+
+- [x] Databases
+- [x] Users
+- [x] Teams
+- [x] Messaging
+- [x] Locale
+- [x] Avatars
+- [x] Storage (Beta)
+- [x] Functions (Beta)
+
+> Please note that the Storage and Functions tools are currently in beta and methods like createFile and createDeployment are not yet supported.
+
+## Local Development
+
+Clone the repository
+
+```bash
+git clone https://github.com/appwrite/mcp.git
+```
+
+Install `uv`
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Create virtual environment
+
+```bash
+uv venv
+source .venv/bin/activate
+```
+
+## Configuration
+
+Create a `.env` file in the root directory based on `.env.example`:
+
+```env
+APPWRITE_API_KEY=your-api-key
+APPWRITE_PROJECT_ID=your-project-id
+APPWRITE_ENDPOINT=your-endpoint  # Optional, defaults to https://cloud.appwrite.io/v1
+```
+
+Run the server
+
+```bash
+uv run -v --directory ./ mcp-server-appwrite
+```
+
+### Usage with Claude Desktop
+
+Add this to your `claude_desktop_config.json`:
+
+```json
+"mcpServers": {
+  "appwrite": {
+    "command": "uv",
+    "args": [
+      "run",
+      "--directory",
+      "<path-to-repository>",
+      "mcp-server-appwrite"
+    ],
+    "env": {
+      "APPWRITE_PROJECT_ID": "your-project-id",
+      "APPWRITE_API_KEY": "your-api-key",
+      "APPWRITE_ENDPOINT": "your-endpoint"  // Optional
+    }
+  }
+}
+```
+
+Upon successful configuration, you should be able to see the server in the list of available servers in Claude Desktop.
+
+![Claude Desktop Config](images/claude-desktop-integration.png)
+
+### Usage with [Zed](https://github.com/zed-industries/zed)
+
+Add to your Zed settings.json:
+
+```json
+"context_servers": {
+  "appwrite": {
+    "command": "uv",
+    "args": [
+      "run",
+      "--directory",
+      "<path-to-repository>",
+      "mcp-server-appwrite"
+    ],
+    "env": {
+      "APPWRITE_PROJECT_ID": "your-project-id",
+      "APPWRITE_API_KEY": "your-api-key",
+      "APPWRITE_ENDPOINT": "your-endpoint"  // Optional
+    }
+  }
+}
+```
+
+### Usage with [Cursor](https://www.cursor.com/)
+
+Head to Cursor `Settings > Features > MCP Servers` and click on **Add New MCP Server**. Choose the type as `Command` and add the command below to the **Command** field.
+
+```bash
+APPWRITE_PROJECT_ID=your-project-id APPWRITE_API_KEY=your-api-key uv run --directory <path_to_repository> mcp-server-appwrite
+```
+
+![Cursor Settings](./images/cursor-integration.png)
+
+## Debugging
+
+You can use the MCP inspector to debug the server. 
+
+```bash
+npx @modelcontextprotocol/inspector \
+  uv \
+  --directory . \
+  run mcp-server-appwrite
+```
+
+Make sure your `.env` file is properly configured before running the inspector. You can then access the inspector at `http://localhost:5173`.
+
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
+
+## Todos
+- Add MCP server to registries
+  - Glama
+  - https://github.com/chatmcp/mcp-directory
+  - https://mcp.so/
+  - https://github.com/punkpeye/awesome-mcp-servers
+  - https://portkey.ai/mcp-servers
+  - https://www.claudemcp.com/servers
+- Add support for SSE server
+- Release to PIP
+- ✅ Add support for env vars
+- Add suppport for resources

mcp_server_appwrite-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+mcp_server_appwrite/__init__.py,sha256=Od9oaUg_ckgJ4jIGa2HijocyauWDPjIC7cBRiV0P4s8,214
+mcp_server_appwrite/__main__.py,sha256=bdaX6xMmFugzSR2QMdXJqanRx_Jh25jACJDqjE9cKEc,75
+mcp_server_appwrite/server.py,sha256=bR_1QL9hmFeNS4aNOZbgEHkZCfQI7iBOvAnL1BYRkoU,3960
+mcp_server_appwrite/service.py,sha256=WwKoh9o7W7ZOmhY0yg6k4R2cghQRe-yMTNbFtB6TFT8,2895
+mcp_server_appwrite/tool_manager.py,sha256=AfRjLyMpplYjF2VJna7frXDiDUZKRN8WQu9R8j3dxPc,718
+mcp_server_appwrite-0.1.0.dist-info/METADATA,sha256=f6USs_RH5GLiD_tp4IC5Q8bxbt6dOzwrBbMxAxT1J4s,3786
+mcp_server_appwrite-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_server_appwrite-0.1.0.dist-info/entry_points.txt,sha256=-FBKUOp-Qmo9FldmiT3JUyF7djSeo8lLhxljOosuHkQ,74
+mcp_server_appwrite-0.1.0.dist-info/licenses/LICENSE,sha256=PXzk1HbuQMAkLdHzwnBLTBIHFmgDZM0Ez2lw2gX2UQs,1096
+mcp_server_appwrite-0.1.0.dist-info/RECORD,,

mcp_server_appwrite-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_server_appwrite-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-server-appwrite = mcp_server_appwrite.__main__:main

mcp_server_appwrite-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Christy Jacob
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+1. The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+2. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.