awslabs.memcached-mcp-server 1.0.2__tar.gz → 1.0.3__tar.gz

{awslabs_memcached_mcp_server-1.0.2 → awslabs_memcached_mcp_server-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awslabs.memcached-mcp-server
-Version: 1.0.2
+Version: 1.0.3
 Summary: An AWS Labs Model Context Protocol (MCP) server for Amazon ElastiCache Memcached
 Project-URL: homepage, https://awslabs.github.io/mcp/
 Project-URL: docs, https://awslabs.github.io/mcp/servers/memcached-mcp-server/
@@ -40,6 +40,17 @@ MCP server for interacting with Amazon ElastiCache Memcached through a secure an
 - Secure communication with SSL/TLS encryption
 - Automatic connection management and pooling
 - Built-in retry mechanism for failed operations
+- Readonly mode to prevent write operations
+
+### Readonly Mode
+
+The server can be started in readonly mode, which prevents any write operations from being performed. This is useful for scenarios where you want to ensure that no data is modified, such as:
+
+- Read-only replicas
+- Production environments where writes should be restricted
+- Debugging and monitoring without risk of data modification
+
+When readonly mode is enabled, any attempt to perform a write operation (set, add, replace, delete, etc.) will return an error message.
 
 ## Prerequisites
 
@@ -51,6 +62,8 @@ MCP server for interacting with Amazon ElastiCache Memcached through a secure an
 
 ## Installation
 
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)](https://cursor.com/install-mcp?name=awslabs.memcached-mcp-server&config=eyJjb21tYW5kIjoidXZ4IGF3c2xhYnMubWVtY2FjaGVkLW1jcC1zZXJ2ZXJAbGF0ZXN0IiwiZW52Ijp7IkZBU1RNQ1BfTE9HX0xFVkVMIjoiRVJST1IiLCJNRU1DQUNIRURfSE9TVCI6InlvdXItbWVtY2FjaGVkLWhvc3QiLCJNRU1DQUNIRURfUE9SVCI6IjExMjExIn0sImRpc2FibGVkIjpmYWxzZSwiYXV0b0FwcHJvdmUiOltdfQ%3D%3D)
+
 Here are some ways you can work with MCP (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
 
 ```json
@@ -71,6 +84,26 @@ Here are some ways you can work with MCP (e.g. for Amazon Q Developer CLI MCP, `
 }
 ```
 
+To run in readonly mode:
+
+```json
+{
+  "mcpServers": {
+    "awslabs.memcached-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.memcached-mcp-server@latest", "--readonly"],
+      "env": {
+        "FASTMCP_LOG_LEVEL": "ERROR",
+        "MEMCACHED_HOST": "your-memcached-host",
+        "MEMCACHED_PORT": "11211"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
 or docker after a successful `docker build -t awslabs/memcached-mcp-server .`:
 
 ```json
@@ -98,6 +131,34 @@ or docker after a successful `docker build -t awslabs/memcached-mcp-server .`:
 }
 ```
 
+To run in readonly mode with Docker:
+
+```json
+{
+  "mcpServers": {
+    "awslabs.memcached-mcp-server": {
+      "command": "docker",
+      "args": [
+        "run",
+        "--rm",
+        "--interactive",
+        "--env",
+        "FASTMCP_LOG_LEVEL=ERROR",
+        "--env",
+        "MEMCACHED_HOST=your-memcached-host",
+        "--env",
+        "MEMCACHED_PORT=11211",
+        "awslabs/memcached-mcp-server:latest",
+        "--readonly"
+      ],
+      "env": {},
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
 ## Configuration
 
 ### Basic Connection Settings
@@ -155,3 +216,11 @@ docker run -p 8080:8080 \
   -e MEMCACHED_PORT=11211 \
   awslabs/memcached-mcp-server
 ```
+
+To run in readonly mode:
+```bash
+docker run -p 8080:8080 \
+  -e MEMCACHED_HOST=host.docker.internal \
+  -e MEMCACHED_PORT=11211 \
+  awslabs/memcached-mcp-server --readonly
+```

{awslabs_memcached_mcp_server-1.0.2 → awslabs_memcached_mcp_server-1.0.3}/README.md

@@ -10,6 +10,17 @@ MCP server for interacting with Amazon ElastiCache Memcached through a secure an
 - Secure communication with SSL/TLS encryption
 - Automatic connection management and pooling
 - Built-in retry mechanism for failed operations
+- Readonly mode to prevent write operations
+
+### Readonly Mode
+
+The server can be started in readonly mode, which prevents any write operations from being performed. This is useful for scenarios where you want to ensure that no data is modified, such as:
+
+- Read-only replicas
+- Production environments where writes should be restricted
+- Debugging and monitoring without risk of data modification
+
+When readonly mode is enabled, any attempt to perform a write operation (set, add, replace, delete, etc.) will return an error message.
 
 ## Prerequisites
 
@@ -21,6 +32,8 @@ MCP server for interacting with Amazon ElastiCache Memcached through a secure an
 
 ## Installation
 
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)](https://cursor.com/install-mcp?name=awslabs.memcached-mcp-server&config=eyJjb21tYW5kIjoidXZ4IGF3c2xhYnMubWVtY2FjaGVkLW1jcC1zZXJ2ZXJAbGF0ZXN0IiwiZW52Ijp7IkZBU1RNQ1BfTE9HX0xFVkVMIjoiRVJST1IiLCJNRU1DQUNIRURfSE9TVCI6InlvdXItbWVtY2FjaGVkLWhvc3QiLCJNRU1DQUNIRURfUE9SVCI6IjExMjExIn0sImRpc2FibGVkIjpmYWxzZSwiYXV0b0FwcHJvdmUiOltdfQ%3D%3D)
+
 Here are some ways you can work with MCP (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
 
 ```json
@@ -41,6 +54,26 @@ Here are some ways you can work with MCP (e.g. for Amazon Q Developer CLI MCP, `
 }
 ```
 
+To run in readonly mode:
+
+```json
+{
+  "mcpServers": {
+    "awslabs.memcached-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.memcached-mcp-server@latest", "--readonly"],
+      "env": {
+        "FASTMCP_LOG_LEVEL": "ERROR",
+        "MEMCACHED_HOST": "your-memcached-host",
+        "MEMCACHED_PORT": "11211"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
 or docker after a successful `docker build -t awslabs/memcached-mcp-server .`:
 
 ```json
@@ -68,6 +101,34 @@ or docker after a successful `docker build -t awslabs/memcached-mcp-server .`:
 }
 ```
 
+To run in readonly mode with Docker:
+
+```json
+{
+  "mcpServers": {
+    "awslabs.memcached-mcp-server": {
+      "command": "docker",
+      "args": [
+        "run",
+        "--rm",
+        "--interactive",
+        "--env",
+        "FASTMCP_LOG_LEVEL=ERROR",
+        "--env",
+        "MEMCACHED_HOST=your-memcached-host",
+        "--env",
+        "MEMCACHED_PORT=11211",
+        "awslabs/memcached-mcp-server:latest",
+        "--readonly"
+      ],
+      "env": {},
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
 ## Configuration
 
 ### Basic Connection Settings
@@ -125,3 +186,11 @@ docker run -p 8080:8080 \
   -e MEMCACHED_PORT=11211 \
   awslabs/memcached-mcp-server
 ```
+
+To run in readonly mode:
+```bash
+docker run -p 8080:8080 \
+  -e MEMCACHED_HOST=host.docker.internal \
+  -e MEMCACHED_PORT=11211 \
+  awslabs/memcached-mcp-server --readonly
+```

awslabs_memcached_mcp_server-1.0.3/awslabs/memcached_mcp_server/context.py

@@ -0,0 +1,39 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Context management for Memcached MCP Server."""
+
+
+class Context:
+    """Context class for Memcached MCP Server."""
+
+    _readonly = False
+
+    @classmethod
+    def initialize(cls, readonly: bool = False):
+        """Initialize the context.
+
+        Args:
+            readonly: Whether to run in readonly mode
+        """
+        cls._readonly = readonly
+
+    @classmethod
+    def readonly_mode(cls) -> bool:
+        """Check if the server is running in readonly mode.
+
+        Returns:
+            True if readonly mode is enabled, False otherwise
+        """
+        return cls._readonly

{awslabs_memcached_mcp_server-1.0.2 → awslabs_memcached_mcp_server-1.0.3}/awslabs/memcached_mcp_server/main.py

@@ -14,7 +14,9 @@
 
 """awslabs memcached MCP Server implementation."""
 
+import argparse
 from awslabs.memcached_mcp_server.common.server import mcp
+from awslabs.memcached_mcp_server.context import Context
 from awslabs.memcached_mcp_server.tools import cache  # noqa: F401
 from loguru import logger
 from starlette.requests import Request  # noqa: F401
@@ -41,6 +43,18 @@ class MemcachedMCPServer:
 
 def main():
     """Run the MCP server with CLI argument support."""
+    parser = argparse.ArgumentParser(
+        description='An AWS Labs Model Context Protocol (MCP) server for interacting with Memcached'
+    )
+    parser.add_argument(
+        '--readonly',
+        action=argparse.BooleanOptionalAction,
+        help='Prevents the MCP server from performing mutating operations',
+    )
+
+    args = parser.parse_args()
+    Context.initialize(args.readonly)
+
     logger.info('Amazon ElastiCache Memcached MCP Server Started...')
     MemcachedMCPServer().run()
 

{awslabs_memcached_mcp_server-1.0.2 → awslabs_memcached_mcp_server-1.0.3}/awslabs/memcached_mcp_server/tools/cache.py

@@ -16,6 +16,7 @@
 
 from awslabs.memcached_mcp_server.common.connection import MemcachedConnectionManager
 from awslabs.memcached_mcp_server.common.server import mcp
+from awslabs.memcached_mcp_server.context import Context
 from pymemcache.exceptions import MemcacheError
 from typing import Any, Dict, List, Optional
 
@@ -106,6 +107,9 @@ async def cache_set(key: str, value: Any, expire: Optional[int] = None) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         client.set(key, value, expire=expire)
@@ -128,6 +132,9 @@ async def cache_cas(key: str, value: Any, cas: int, expire: Optional[int] = None
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.cas(key, value, cas, expire=expire):
@@ -149,6 +156,9 @@ async def cache_set_many(mapping: Dict[str, Any], expire: Optional[int] = None)
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         failed = client.set_many(mapping, expire=expire)
@@ -186,6 +196,9 @@ async def cache_add(key: str, value: Any, expire: Optional[int] = None) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.add(key, value, expire=expire):
@@ -208,6 +221,9 @@ async def cache_replace(key: str, value: Any, expire: Optional[int] = None) -> s
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.replace(key, value, expire=expire):
@@ -229,6 +245,9 @@ async def cache_append(key: str, value: str) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.append(key, value):
@@ -249,6 +268,9 @@ async def cache_prepend(key: str, value: str) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.prepend(key, value):
@@ -268,6 +290,9 @@ async def cache_delete(key: str) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.delete(key):
@@ -287,6 +312,9 @@ async def cache_delete_many(keys: List[str]) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         failed = client.delete_many(keys)
@@ -321,6 +349,9 @@ async def cache_incr(key: str, value: int = 1) -> str:
     Returns:
         New value or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         result = client.incr(key, value)
@@ -342,6 +373,9 @@ async def cache_decr(key: str, value: int = 1) -> str:
     Returns:
         New value or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         result = client.decr(key, value)
@@ -363,6 +397,9 @@ async def cache_touch(key: str, expire: int) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         if client.touch(key, expire):
@@ -400,6 +437,9 @@ async def cache_flush_all(delay: int = 0) -> str:
     Returns:
         Success message or error message
     """
+    if Context.readonly_mode():
+        return 'Operation not permitted: Server is in readonly mode'
+
     try:
         client = MemcachedConnectionManager.get_connection()
         client.flush_all(delay=delay)

{awslabs_memcached_mcp_server-1.0.2 → awslabs_memcached_mcp_server-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "awslabs.memcached-mcp-server"
-version = "1.0.2"
+version = "1.0.3"
 description = "An AWS Labs Model Context Protocol (MCP) server for Amazon ElastiCache Memcached"
 readme = "README.md"
 requires-python = ">=3.10"

awslabs_memcached_mcp_server-1.0.3/tests/test_cache_readonly.py

@@ -0,0 +1,163 @@
+"""Tests for readonly mode in Cache functionality in the memcached MCP server."""
+
+import pytest
+from awslabs.memcached_mcp_server.tools.cache import (
+    cache_add,
+    cache_append,
+    cache_cas,
+    cache_decr,
+    cache_delete,
+    cache_delete_many,
+    cache_flush_all,
+    cache_incr,
+    cache_prepend,
+    cache_replace,
+    cache_set,
+    cache_set_many,
+    cache_touch,
+)
+from unittest.mock import Mock, patch
+
+
+class TestCacheReadonly:
+    """Tests for Cache operations in readonly mode."""
+
+    @pytest.fixture
+    def mock_client(self):
+        """Create a mock Memcached client."""
+        with patch(
+            'awslabs.memcached_mcp_server.common.connection.MemcachedConnectionManager.get_connection'
+        ) as mock:
+            client = Mock()
+            mock.return_value = client
+            yield client
+
+    @pytest.fixture
+    def mock_context(self):
+        """Create a mock Context."""
+        with patch('awslabs.memcached_mcp_server.tools.cache.Context') as mock_ctx:
+            mock_ctx.readonly_mode.return_value = True
+            yield mock_ctx
+
+    @pytest.mark.asyncio
+    async def test_cache_set_readonly(self, mock_client, mock_context):
+        """Test setting a value in readonly mode."""
+        key = 'test_key'
+        value = 'test_value'
+
+        result = await cache_set(key, value)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.set.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_delete_readonly(self, mock_client, mock_context):
+        """Test deleting a value in readonly mode."""
+        key = 'test_key'
+
+        result = await cache_delete(key)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.delete.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_incr_readonly(self, mock_client, mock_context):
+        """Test incrementing a counter in readonly mode."""
+        key = 'counter'
+
+        result = await cache_incr(key)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.incr.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_append_readonly(self, mock_client, mock_context):
+        """Test appending to a value in readonly mode."""
+        key = 'test_key'
+        value = 'test_value'
+
+        result = await cache_append(key, value)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.append.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_flush_all_readonly(self, mock_client, mock_context):
+        """Test flushing all cache entries in readonly mode."""
+        result = await cache_flush_all()
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.flush_all.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_cas_readonly(self, mock_client, mock_context):
+        """Test CAS operation in readonly mode."""
+        key = 'test_key'
+        value = 'test_value'
+        cas = 123
+
+        result = await cache_cas(key, value, cas)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.cas.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_set_many_readonly(self, mock_client, mock_context):
+        """Test setting multiple values in readonly mode."""
+        mapping = {'key1': 'value1', 'key2': 'value2'}
+
+        result = await cache_set_many(mapping)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.set_many.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_add_readonly(self, mock_client, mock_context):
+        """Test adding a value in readonly mode."""
+        key = 'test_key'
+        value = 'test_value'
+
+        result = await cache_add(key, value)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.add.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_replace_readonly(self, mock_client, mock_context):
+        """Test replacing a value in readonly mode."""
+        key = 'test_key'
+        value = 'test_value'
+
+        result = await cache_replace(key, value)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.replace.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_prepend_readonly(self, mock_client, mock_context):
+        """Test prepending to a value in readonly mode."""
+        key = 'test_key'
+        value = 'test_value'
+
+        result = await cache_prepend(key, value)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.prepend.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_delete_many_readonly(self, mock_client, mock_context):
+        """Test deleting multiple values in readonly mode."""
+        keys = ['key1', 'key2']
+
+        result = await cache_delete_many(keys)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.delete_many.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_decr_readonly(self, mock_client, mock_context):
+        """Test decrementing a counter in readonly mode."""
+        key = 'counter'
+
+        result = await cache_decr(key)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.decr.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cache_touch_readonly(self, mock_client, mock_context):
+        """Test touching a key in readonly mode."""
+        key = 'test_key'
+        expire = 60
+
+        result = await cache_touch(key, expire)
+        assert 'Operation not permitted: Server is in readonly mode' in result
+        mock_client.touch.assert_not_called()

{awslabs_memcached_mcp_server-1.0.2 → awslabs_memcached_mcp_server-1.0.3}/uv.lock

@@ -37,7 +37,7 @@ wheels = [
 
 [[package]]
 name = "awslabs-memcached-mcp-server"
-version = "1.0.1"
+version = "1.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "loguru" },