Byted Redis

# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
#
# 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.

# Volcengine Redis MCP Skill Dependencies

## Python Dependencies
mcp>=1.1.0
volcengine-python-sdk>=4.0.24

# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
#
# 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.

#!/usr/bin/env python3
# /// script
# dependencies = [
#   "mcp>=1.0.0",
# ]
# ///

import asyncio
import json
import os
import sys
from mcp_client import RedisMCPClient


def detect_credential_mode():
    if os.getenv("AUTHORIZATION") or os.getenv("authorization"):
        return "Authorization STS"
    if os.getenv("VOLCENGINE_SESSION_TOKEN"):
        return "AK/SK + SessionToken"
    return "AK/SK"


def pretty_print_json(raw_text: str) -> str:
    try:
        return json.dumps(json.loads(raw_text), indent=2, ensure_ascii=False)
    except Exception:
        return raw_text


async def test_server():
    region = os.getenv("VOLCENGINE_REGION") or "cn-beijing"

    print("Testing Volcengine Redis MCP Server...")
    print(f"Resolved region for requests: {region}")
    print(f"Detected credential mode: {detect_credential_mode()}")

    try:
        async with RedisMCPClient() as client:
            print("\n1. Successfully connected to MCP server.")

            # --- 1. List available tools ---
            tools = await client.list_tools()
            print(f"\n2. Retrieved {len(tools)} tools:")
            for i, tool in enumerate(tools[:5]):  # show first 5
                print(f"  - {tool['name']}: {tool['description'][:60]}...")
            if len(tools) > 5:
                print(f"  ... and {len(tools) - 5} more tools.")

            # --- 2. Test a parameterless read-only tool ---
            print("\n3. Testing tool invocation: describe_regions")
            regions_result = await client.call_tool("describe_regions", {})
            print("  Result:")
            print(f"{pretty_print_json(regions_result)}\n")

            # --- 3. Test an advanced tool with arguments ---
            print("4. Testing tool invocation: describe_db_instances (with args)")
            # Requesting only 1 instance to keep the output concise
            instances_result = await client.call_tool(
                "describe_db_instances", {"region_id": region, "page_size": 1}
            )
            print("  Result:")
            data = json.loads(instances_result)
            if "instances" in data and len(data["instances"]) > 0:
                data["instances"] = data["instances"][:1]
                data["_note"] = (
                    "Output truncated to 1 instance by test script for brevity"
                )
            print(f"{json.dumps(data, indent=2, ensure_ascii=False)}\n")

            print("\nAll tests passed successfully!")

    except Exception as e:
        print(f"\nTest failed: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    asyncio.run(test_server())

# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
#
# 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.

#!/usr/bin/env python3
# /// script
# dependencies = [
#   "mcp>=1.0.0",
# ]
# ///

import os
import sys
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client


AUTH_ENV_NAMES = (
    "VOLCENGINE_ACCESS_KEY",
    "VOLCENGINE_SECRET_KEY",
    "VOLCENGINE_SESSION_TOKEN",
    "VOLCENGINE_REGION",
    "VOLCENGINE_ENDPOINT",
    "AUTHORIZATION",
    "authorization",
)

RUNTIME_ENV_NAMES = (
    "PATH",
    "HOME",
    "USER",
    "TMPDIR",
    "LANG",
    "LC_ALL",
    "LC_CTYPE",
    "SHELL",
    "SSL_CERT_FILE",
    "REQUESTS_CA_BUNDLE",
    "CURL_CA_BUNDLE",
    "HTTP_PROXY",
    "HTTPS_PROXY",
    "ALL_PROXY",
    "NO_PROXY",
    "http_proxy",
    "https_proxy",
    "all_proxy",
    "no_proxy",
    "UV_CACHE_DIR",
    "UV_INDEX_URL",
    "UV_EXTRA_INDEX_URL",
    "UV_PYTHON",
)


class RedisMCPClient:
    def __init__(self, env: dict[str, str] | None = None):
        self.session = None
        self._exit_stack = None
        self._env = env

    def _credential_env(self) -> dict[str, str]:
        return self._env if self._env is not None else os.environ

    def _build_server_env(self) -> dict[str, str]:
        server_env = {}
        for name in RUNTIME_ENV_NAMES:
            value = os.environ.get(name)
            if value:
                server_env[name] = value

        for name in AUTH_ENV_NAMES:
            value = self._credential_env().get(name)
            if value:
                server_env[name] = value

        return server_env

    async def connect(self):
        credential_env = self._credential_env()

        # Check credentials. The stdio skill client supports either:
        # 1) AK/SK (optionally with VOLCENGINE_SESSION_TOKEN)
        # 2) AUTHORIZATION / authorization with a Bearer token payload
        has_aksk = bool(
            credential_env.get("VOLCENGINE_ACCESS_KEY")
            and credential_env.get("VOLCENGINE_SECRET_KEY")
        )
        has_authorization = bool(
            credential_env.get("AUTHORIZATION") or credential_env.get("authorization")
        )
        if not has_aksk and not has_authorization:
            print(
                "Error: Missing Redis MCP credentials. Provide either VOLCENGINE_ACCESS_KEY + VOLCENGINE_SECRET_KEY "
                "(optionally with VOLCENGINE_SESSION_TOKEN) or AUTHORIZATION/authorization.",
                file=sys.stderr,
            )
            print(
                "Example 1: define VOLCENGINE_ACCESS_KEY and VOLCENGINE_SECRET_KEY in the environment.",
                file=sys.stderr,
            )
            print(
                "Example 2: define AUTHORIZATION in the environment with a Bearer token.",
                file=sys.stderr,
            )
            sys.exit(1)

        # To support standalone skill distribution without requiring local codebase,
        # we default to using `uvx` to fetch and run the server from the remote repo.
        server_params = StdioServerParameters(
            command="uvx",
            args=[
                "--from",
                "git+https://github.com/volcengine/mcp-server.git#subdirectory=server/mcp_server_redis",
                "mcp-server-redis",
                "-t",
                "stdio",
            ],
            env=self._build_server_env(),
        )

        from contextlib import AsyncExitStack

        self._exit_stack = AsyncExitStack()

        # Start the client
        try:
            read, write = await self._exit_stack.enter_async_context(
                stdio_client(server_params)
            )
            self.session = await self._exit_stack.enter_async_context(
                ClientSession(read, write)
            )
            await self.session.initialize()
        except Exception as e:
            print(f"Failed to connect to MCP server: {e}", file=sys.stderr)
            sys.exit(1)

    async def list_tools(self):
        """List all available tools."""
        if not self.session:
            raise RuntimeError("Client not connected")
        result = await self.session.list_tools()
        tools = []
        for t in result.tools:
            tools.append({"name": t.name, "description": t.description or ""})
        return tools

    async def call_tool(self, name: str, arguments: dict = None):
        """Call a specific tool."""
        if not self.session:
            raise RuntimeError("Client not connected")
        arguments = arguments or {}
        result = await self.session.call_tool(name, arguments)

        # Parse text content from response
        output = ""
        for content in result.content:
            if content.type == "text":
                output += content.text + "\n"
        return output

    async def close(self):
        if self._exit_stack:
            await self._exit_stack.aclose()
            self.session = None

    async def __aenter__(self):
        await self.connect()
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.close()

# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
#
# 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.

#!/bin/bash
# Start Volcengine Redis MCP service as a background process

LOG_DIR="logs"
mkdir -p "$LOG_DIR"

if [ -f "volcengine_redis_mcp.pid" ]; then
    echo "Volcengine Redis MCP server is already running with PID $(cat volcengine_redis_mcp.pid)."
    exit 1
fi

LOG_FILE="${LOG_DIR}/volcengine_redis_mcp_$(date +%Y%m%d_%H%M%S).log"

# Use uvx to fetch and run the server from the remote Github repository
# This makes the skill script completely standalone
echo "Starting Volcengine Redis MCP Server..."
nohup uvx --from git+https://github.com/volcengine/mcp-server.git#subdirectory=server/mcp_server_redis mcp-server-redis -t stdio > "$LOG_FILE" 2>&1 &PID=$!

echo $PID > volcengine_redis_mcp.pid
echo "Volcengine Redis MCP Server started with PID $PID."
echo "Logs are being written to $LOG_FILE"

# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
#
# 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.

#!/bin/bash
# Check the status of the Volcengine Redis MCP service

if [ ! -f "volcengine_redis_mcp.pid" ]; then
    echo "Status: STOPPED (volcengine_redis_mcp.pid not found)"
    exit 0
fi

PID=$(cat volcengine_redis_mcp.pid)
if kill -0 $PID > /dev/null 2>&1; then
    echo "Status: RUNNING (PID: $PID)"
    echo "Recent logs:"
    ls -t logs/volcengine_redis_mcp_*.log | head -1 | xargs tail -n 10
else
    echo "Status: STOPPED (PID file exists but process $PID is not running)"
    rm volcengine_redis_mcp.pid
fi

# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
#
# 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.

#!/bin/bash
# Stop the background Volcengine Redis MCP service

if [ ! -f "volcengine_redis_mcp.pid" ]; then
    echo "No volcengine_redis_mcp.pid found. Server is likely not running."
    exit 0
fi

PID=$(cat volcengine_redis_mcp.pid)
if kill -0 $PID > /dev/null 2>&1; then
    echo "Stopping Volcengine Redis MCP server with PID $PID..."
    kill $PID
    sleep 2
    if kill -0 $PID > /dev/null 2>&1; then
        echo "Force killing Volcengine Redis MCP server..."
        kill -9 $PID
    fi
    echo "Volcengine Redis MCP server stopped."
else
    echo "Volcengine Redis MCP server process $PID not found. Cleaning up pid file."
fi

rm volcengine_redis_mcp.pid