Appwrite MCP Server

Instructions

Implementation Reference

• src/mcp_server_appwrite/server.py:70-72 (registration)

  Registers the TablesDB service (tables_db) conditionally based on CLI flag. This service auto-generates MCP tools for all public methods on TablesDB(client), naming them 'tables_db_{method_name}', so 'tables_db_update_boolean_column' is registered if TablesDB has 'update_boolean_column' method.

  if args.tables_db:
      tools_manager.register_service(Service(TablesDB(client), "tables_db"))
  if args.users:

• src/mcp_server_appwrite/server.py:94-95 (registration)

  Default registration of TablesDB service (tables_db) if no other services specified. Enables the dynamic tool generation including 'tables_db_update_boolean_column'.

  tools_manager.register_service(Service(TablesDB(client), "tables_db"))

• src/mcp_server_appwrite/service.py:73-127 (registration)

  Dynamically lists all public methods on the service instance (e.g., TablesDB), overrides names if any, parses docstrings, generates JSON schema from type hints for parameters, creates MCP Tool objects, and maps tool_name to {'definition': Tool, 'function': bound_method}. This is where 'tables_db_update_boolean_column' tool is defined and schematized.

  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 = parse(original_func.__doc__)
          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}'"
              
              for doc_param in docstring.params:
                  if doc_param.arg_name == param_name:
                      properties[param_name]["description"] = doc_param.description
  
              if param.default is param.empty:
                  required.append(param_name)
  
          tool_definition = Tool(
              name=tool_name,
              description=f"{docstring.short_description or "No description available"}",
              inputSchema={
                  "type": "object",
                  "properties": properties,
                  "required": required
              }
          )
          
          tools[tool_name] = {
              "definition": tool_definition,
              "function": func
          }
          
      return tools

• src/mcp_server_appwrite/server.py:103-123 (handler)

  Generic MCP tool execution handler. Retrieves the tool info from registry, gets the bound method (e.g., TablesDB.update_boolean_column), calls it with arguments, and returns the result as TextContent. This executes the 'tables_db_update_boolean_column' tool.

  @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)}")]

• src/mcp_server_appwrite/tool_manager.py:10-13 (helper)

  ToolManager.register_service appends the service and updates the tools_registry with tools from service.list_tools(), making them available for get_tool and list_tools.

  def register_service(self, service: Service):
      """Register a new service and its tools"""
      self.services.append(service)
      self.tools_registry.update(service.list_tools())