### Install and Run ByteHouse MCP Server

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_bytehouse/README_zh.md

This snippet outlines the steps to install and run the ByteHouse MCP Server locally. It includes setting environment variables for database connection, installing dependencies, and starting the server. Ensure Python 3.12 is used.

```bash
export BYTEHOUSE_HOST="<your_bytehouse_host>"
export BYTEHOUSE_PORT="<your_bytehouse_port>"
export BYTEHOUSE_USER="<your_bytehouse_user>"
export BYTEHOUSE_PASSWORD="<your_bytehouse_password>"
export BYTEHOUSE_SECURE="true"
export BYTEHOUSE_VERIFY="true"
export BYTEHOUSE_CONNECT_TIMEOUT="60"
export BYTEHOUSE_SEND_RECEIVE_TIMEOUT="60"

pip install -r requirements.txt
python3 -m mcp_bytehouse.main -t sse
```

--------------------------------

### Setup Node.js MCP Server

Source: https://context7.com/volcengine/mcp-server/llms.txt

Guide for setting up and running the Node.js version of the MCP Server. It covers installing project dependencies using npm, building TypeScript code, and running the compiled server application.

```bash
# Install dependencies
cd server/mcp_server_veen/nodejs
npm install

# Build TypeScript
npm run build

# Run compiled server
node dist/index.js

# Or use npm start if configured
npm start
```

--------------------------------

### Configure ECS MCP Server with uvx

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_ecs/README_zh.md

A JSON configuration example for starting the ECS MCP server using 'uvx', specifying the Git repository, subdirectory, command, arguments, and environment variables.

```json
{
    "mcpServers": {
        "mcp-server-ecs": {
            "command": "uvx",
            "args": [
                "--from",
                "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_ecs",
                "mcp-server-ecs"
            ],
            "env": {
                "VOLCENGINE_ACCESS_KEY": "",
                "VOLCENGINE_SECRET_KEY": "",
                "VOLCENGINE_REGION": "",
                "VOLCENGINE_ENDPOINT": "",
                "MCP_SERVER_PORT": ""
            }
        }
    }
}
```

--------------------------------

### Install Python MCP Server with uvx or uv

Source: https://context7.com/volcengine/mcp-server/llms.txt

Instructions for installing the Python MCP Server using package managers like `uvx` for isolated environments or `uv` for development setups. It includes commands for cloning the repository, installing dependencies, and running the server with different transport options.

```bash
# Install using uvx for isolated environment
uvx --from "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_alb/python" mcp-server-alb

# Or install with uv for development
cd server/mcp_server_alb/python
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
uv pip install -e .

# Run with custom transport
python -m src.alb.server --transport stdio
python -m src.alb.server --transport sse
```

--------------------------------

### MCP Server Client Configuration Example

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_vpn/README.md

A JSON configuration example for the MCP server client, specifying server details, command to run, arguments, and environment variables. This includes Volcengine credentials and endpoint.

```json
{
  "mcpServers": {
    "mcp-server-vpn": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_vpn",
        "mcp-server-vpn"
      ],
      "env": {
        "VOLCENGINE_ENDPOINT": "open.volcengineapi.com",
        "VOLCENGINE_REGION": "cn-beijing",
        "VOLCENGINE_ACCESS_KEY": "your-access-key",
        "VOLCENGINE_SECRET_KEY": "your-secret-key"
      }
    }
  }
}
```

--------------------------------

### Install mcp-server-git using PIP

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_rtc/README_zh.md

This command installs the mcp-server-git package using pip, allowing you to run it as a script. Ensure you have Python and pip installed.

```bash
pip install mcp-server-git
```

--------------------------------

### Configure and Run Mcp Server with Environment Variables

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README.md

Example of setting environment variables `MCP_SERVER_PORT` and `TOOL_SERVER_ENDPOINT` before starting the MCP server using `uv`. This allows customization of the server's port and tool server connection.

```bash
# Set fastmcp port and [tool server]() endpoint here
export MCP_SERVER_PORT=8000
export TOOL_SERVER_ENDPOINT={endpoint}
cd mcp_server_computer_use
uv run mcp-server-computer-use
```

--------------------------------

### Start Mcp-Server with UV (Standard)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README_zh.md

Starts the mcp-server-computer-use application using the 'uv run' command. This is the default method for running the server.

```bash
cd mcp_serve_computer_use
uv run mcp-server-computer-use
```

--------------------------------

### Configure and Start mcp-server with UVX

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_knowledgebase/README_zh.md

Configuration JSON for starting the mcp-server Knowledge Base using UVX. It specifies the command, arguments including the repository source, and environment variables for authentication and configuration.

```json
{
  "mcpServers": {
    "knowledgebase": {
      "command": "uvx",
        "args": [
          "--from",
          "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_knowledgebase",
          "mcp-server-knowledgebase"
        ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "your-access-key",
        "VOLCENGINE_SECRET_KEY": "your-secret-key", 
        "KNOWLEDGE_BASE_PROJECT": "your-project-name",
        "KNOWLEDGE_BASE_REGION": "your-region"
      }
    }
  }
}
```

--------------------------------

### Sync Dependencies and Build MCP Server

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_ga/README.md

Synchronizes project dependencies using `uv` and then builds the MCP server. These commands are essential steps in the installation and deployment process.

```bash
uv sync
uv build
```

--------------------------------

### Install Dependencies

Source: https://github.com/volcengine/mcp-server/blob/main/app/general_client/README.md

Installs the necessary Python packages for the MCP client from a requirements file. Ensure you have Python 3.10 to 3.12 installed.

```bash
pip install -r requirement.txt
```

--------------------------------

### Start mcp-server Knowledge Base with UV

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_knowledgebase/README_zh.md

Starts the mcp-server Knowledge Base service using the UV ASGI server. Supports standard output and Server-Sent Events (SSE) modes.

```bash
cd mcp-server/server/mcp_server_knowledgebase
uv run mcp-server-knowledgebase

# Start with SSE mode (default is stdio)
uv run mcp-server-knowledgebase -t sse
```

--------------------------------

### Install uv Package Manager

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README.md

Instructions for installing the `uv` package manager on Linux/macOS and Windows systems. This is a prerequisite for running the MCP server.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

```bash
pip install uv
```

--------------------------------

### Describe Topics Tool Output Example

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_tls/README.md

An example of the output structure for the describe_topics_tool, showing details of topics including name, ID, creation time, and shard count.

```json
{
    "total": 1,
    "topics": [
        {
            "topic_name": "your topic name",
            "topic_id": "your topic id",
            "project_id": "your project id",
            "ttl": 30,
            "create_time": "2022-06-22 16:05:27",
            "modify_time": "2025-03-10 17:19:54",
            "shard_count": 6,
            "description": "",
            "auto_split": false,
            "max_split_shard": 0,
            "enable_tracking": false,
            "time_key": "",
            "time_format": "",
            "tags": null,
            "log_public_ip": true,
            "enable_hot_ttl": false,
            "hot_ttl": 0,
            "cold_ttl": 0,
            "archive_ttl": 0
        }
    ]
}
```

--------------------------------

### Example Natural Language Queries for MCP Server

Source: https://context7.com/volcengine/mcp-server/llms.txt

This section provides examples of natural language queries and their corresponding MCP server calls and responses. It illustrates how users can interact with cloud resources like ALB instances, edge computing instances, and manage their states using conversational commands. The format shows the user query, the API calls made, and the expected return data.

```plaintext
User: "List all ALB instances"
-> Calls: describe_load_balancers({})
<- Returns: [{"LoadBalancerId": "alb-123", "LoadBalancerName": "prod-alb", "Status": "Active"}]

User: "Get ALB instance with private IP 192.168.1.16 and show its listeners"
-> Step 1: describe_load_balancers({"Filters": [{"Name": "PrivateIpAddress", "Values": ["192.168.1.16"]}]})
-> Step 2: describe_listeners({"LoadBalancerId": "alb-xyz"})
<- Returns: Formatted response combining instance and listener details

User: "List all stopped edge computing instances"
-> Calls: list_instances({"status": "stop"})
<- Returns: [{"instance_identity": "i-abc123", "status": "stop", "spec_names": "ecs.g2.large"}]

User: "Start edge instance i-abc123"
-> Calls: start_instances({"instance_identities": "i-abc123"})
<- Returns: {"RequestId": "req-123", "Status": "Success"}
```

--------------------------------

### Deploy MCP Server with UVX Configuration

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_askecho_search_infinity/README.md

Configuration example for deploying the MCP Server's web search infinity component using UVX. It specifies the Git source, subdirectory, and environment variables for authentication.

```json
{
  "mcpServers": {
    "mcp-server-askecho-search-infinity": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_askecho_search_infinity",
        "mcp-server-askecho-search-infinity"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "",
        "VOLCENGINE_SECRET_KEY": "",
        "ASK_ECHO_SEARCH_INFINITY_API_KEY": ""
      }
    }
  }
}
```

--------------------------------

### Start MCP Client

Source: https://github.com/volcengine/mcp-server/blob/main/app/general_client/README.md

Initiates the MCP client application. This script connects to the running MCP server and is ready to process queries. It requires Python 3.

```python
python3 client.py
```

--------------------------------

### Start Computer Use Mcp Server with uv

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README.md

Commands to start the Computer Use Mcp Server using the `uv` command-line tool. It shows how to run in default stdio mode and with SSE (Server-Sent Events) mode.

```bash
cd mcp_serve_computer_use
uv run mcp-server-computer-use
```

```bash
uv run mcp-server-computer-use -t sse
```

--------------------------------

### Install VolcEngine EBS MCP Server using uv

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_ebs/README.md

This command installs the VolcEngine EBS MCP Server package using uv, a fast Python package installer. It's recommended for faster installations. Ensure Python 3.10+ is available.

```bash
uv pip install -e .
```

--------------------------------

### Example Calculator Query

Source: https://github.com/volcengine/mcp-server/blob/main/app/general_client/README.md

Demonstrates a sample query to the MCP client, specifically designed to trigger the calculator functionality. The query involves a complex arithmetic expression.

```text
计算12341234/2341234+1123
```

--------------------------------

### Install uv on Windows

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_cen/README.md

This snippet demonstrates how to install uv on a Windows system using PowerShell. uv is a fast Python package installer and virtual environment manager.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Install Viking Memory MCP Server using pip or uv

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_vikingdb_memory/README.md

Installs the Viking Memory MCP Server package. It is recommended to use uv for installation. Ensure Python 3.10 or higher is installed.

```bash
pip install -e .
```

```bash
uv pip install -e .
```

--------------------------------

### Run MCP Server with UV

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_askecho_search_infinity/README.md

Demonstrates how to start the MCP Server's web search infinity component using the UV server. It includes options for default stdio mode and SSE/streamable-http modes.

```bash
cd mcp-server/server/mcp_server_askecho_search_infinity
uv run mcp-server-askecho-search-infinity
```

```bash
# 使用sse/streamable-http模式启动(默认为stdio)
uv run mcp-server-askecho-search-infinity -t sse
```

```bash
uv run mcp-server-askecho-search-infinity -t streamable-http
```

--------------------------------

### Configure and Start Mcp-Server with Environment Variables

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README_zh.md

Sets environment variables for MCP_SERVER_PORT and TOOL_SERVER_ENDPOINT before starting the mcp-server using uv. This allows for custom server configuration.

```bash
export MCP_SERVER_PORT=8000
export TOOL_SERVER_ENDPOINT={endpoint}
cd mcp_server_computer_use
uv run mcp-server-computer-use
```

--------------------------------

### Install uv with pip

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README_zh.md

Installs the 'uv' package manager using pip. This command is used across different operating systems after uv is installed.

```bash
pip install uv
```

--------------------------------

### Install veFaaS MCP Server using uvx

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_vefaas_function/README.md

This configuration demonstrates how to use `uvx` to quickly set up the veFaaS MCP Server locally. It requires specifying the Git repository for the server and setting environment variables for access keys.

```json
{
  "mcpServers": {
    "vefaas": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_vefaas_function",
        "mcp-server-vefaas-function"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "xxx",
        "VOLCENGINE_SECRET_KEY": "xxx"
      }
    }
  }
}
```

--------------------------------

### Install MCP Server Package

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_knowledgebase/README.md

Installs the MCP server package using pip or uv. Ensure Python 3.10 or higher is installed. This command is used for setting up the project locally.

```bash
pip install -e .

```

```bash
uv pip install -e .

```

--------------------------------

### Install VolcEngine EBS MCP Server using pip

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_ebs/README.md

This command installs the VolcEngine EBS MCP Server package using pip. Ensure you have Python 3.10 or higher installed. This is a prerequisite for running the server.

```bash
pip install -e .
```

--------------------------------

### Run mcp-server-git using Python

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_rtc/README_zh.md

This command executes the mcp-server-git as a Python module after installation. It's a convenient way to launch the server.

```bash
python -m mcp_server_git
```

--------------------------------

### Run ByteHouse MCP Server (Bash)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_bytehouse/README.md

Commands to start the ByteHouse MCP Server. Supports stdio transport (default) and SSE transport. No external dependencies are explicitly mentioned for these commands.

```bash
mcp-bytehouse

mcp-bytehouse --transport sse
```

--------------------------------

### Start Calculator MCP Server

Source: https://github.com/volcengine/mcp-server/blob/main/app/general_client/README.md

Launches an MCP server with calculator functionality enabled. This command requires an ARK API key and sets the server to listen on port 8765 using SSE transport. The server is fetched from a git repository.

```bash
ARK_API_KEY=<YOUR API KEY> ARK_TOOL_CACULATOR=true PORT=8765 uvx --from git+https://github.com/volcengine/mcp-server.git#subdirectory=server/mcp_server_ark mcp-server-ark --transport sse
```

--------------------------------

### Run ECS MCP Server with UV

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_ecs/README_zh.md

Demonstrates how to start the ECS MCP server using the UV command-line tool. It shows both the default stdio mode and the streamable-http mode.

```bash
cd mcp-server/server/mcp_server_ecs
uv run mcp-server-ecs
```

```bash
# Use streamable-http mode (default is stdio)
uv run mcp-server-ecs -t streamable-http
```

--------------------------------

### List Apps

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README.md

Lists all installed applications on the cloud phone.

```APIDOC
## POST /list_apps

### Description
Lists all installed applications on the cloud phone.

### Method
POST

### Endpoint
/list_apps

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **No parameters required**

### Request Example
```json
{
  "example": "{}"
}
```

### Response
#### Success Response (200)
- **result** (object) - Contains a list of installed applications.
  - **AppList** (array) - An array of application objects.
    - **app_id** (string) - The application's unique identifier.
    - **app_name** (string) - The name of the application.
    - **app_status** (string) - The status of the application (e.g., 'undeployed').
    - **package_name** (string) - The package name of the application.

#### Response Example
```json
{
  "result": {
    "AppList": [
      {
        "app_id": "12345",
        "app_name": "Douyin",
        "app_status": "installed",
        "package_name": "com.ss.android.ugc.aweme"
      }
    ]
  }
}
```
```

--------------------------------

### Configure MCP Server CloudSearch with UVX

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_cloudsearch/README.md

Configuration for running the MCP Server CloudSearch using the 'uvx' command, typically for installations from a Git repository. It specifies the command, arguments to fetch and run the server, and environment variables for authentication.

```json
{
  "mcpServers": {
    "mcp-server-cloudsearch": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server.git#subdirectory=server/mcp_server_cloudsearch",
        "mcp-server-cloudsearch"
      ],
      "env": {
        "VOLC_ACCESSKEY": "your_volcengine_ak",
        "VOLC_SECRETKEY": "your_volcengine_sk"
      }
    }
  }
}
```

--------------------------------

### Deploy MCP Server using Docker

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_rtc/README_zh.md

This JSON configuration snippet defines how to run the mcp-server-git using Docker. It includes volume mounts for persistent storage and specifies the image name. Ensure Docker is installed and accessible.

```json
{
  "mcpServers": {
    "git": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--mount",
        "type=bind,src=/Users/username/Desktop,dst=/projects/Desktop",
        "--mount",
        "type=bind,src=/path/to/other/allowed/dir,dst=/projects/other/allowed/dir,ro",
        "--mount",
        "type=bind,src=/path/to/file.txt,dst=/projects/path/to/file.txt",
        "mcp/git"
      ]
    }
  }
}
```

--------------------------------

### Run MCP Server with UV

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_vpn/README.md

Example of setting Volcengine environment variables and running the MCP server using the 'uv run' command. This configuration uses stdio transport.

```bash
export VOLCENGINE_ACCESS_KEY=<your_ak>
export VOLCENGINE_SECRET_KEY=<your_sk>
export VOLCENGINE_REGION=cn-beijing
export VOLCENGINE_ENDPOINT=open.volcengineapi.com
export PORT=8000
uv run mcp-server-vpn    # default stdio transport
```

--------------------------------

### Configure MCP Server Run Command (Remote Git)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_tag/README.md

JSON configuration for running the MCP Server tag service by installing directly from a Git repository using 'uvx'. This is useful when the code is not yet cloned locally.

```json
{
    "mcpServers": {
        "tag": {
            "command": "uvx",
            "args": [
                "--from",
                "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_tag",
                "mcp-server-tag"
            ],
            "env": {
                "VOLCENGINE_ACCESS_KEY": "your ak",
                "VOLCENGINE_SECRET_KEY": "your sk",
                "VOLCENGINE_ACCESS_SESSION_TOKEN": "your session token"
            }
        }
    }
}
```

--------------------------------

### Call Tool via streamable-http

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README_en.md

Example of connecting to the MCP Server using streamable-http and calling the `take_screenshot` tool. Covers client setup and tool invocation.

```APIDOC
## Call Tool via streamable-http

### Description
This endpoint allows you to call tools on the MCP Server using the streamable-http protocol. This example demonstrates client initialization and invoking the `take_screenshot` tool.

### Method
`POST` (Implicitly, as tool calls are typically state-changing operations over HTTP)

### Endpoint
`/mcp` (relative to the base URL)

### Parameters

#### Path Parameters
None.

#### Query Parameters
None.

#### Request Body

The `CallToolRequest` structure is used for the request.

- **`Params`** (object) - Required - Parameters for the tool call.
  - **`Name`** (string) - Required - The name of the tool to call (e.g., `take_screenshot`).
  - **`Arguments`** (object) - Optional - A map of arguments for the tool.

### Request Example (Conceptual)

```json
{
  "Params": {
    "Name": "take_screenshot",
    "Arguments": {}
  }
}
```

### Response

#### Success Response (200 OK)

- **`Result`** (object) - The result of the tool execution.

#### Response Example (Conceptual)

```json
{
  "Result": "screenshot_data_or_url"
}
```

### Go Code Example

```go
import (
	"context"
	"log"
	"path/to/your/mobile_use_client"
	"path/to/your/mcp"
)

func main() {
	ctx := context.Background()
	baseUrl := "http://0.0.0.0:8080/mcp"
	authToken := "<your-generated-auth-token>"

	cli, err := mobile_use_client.NewMobileUseStreamableHTTPClient(ctx, baseUrl, map[string]string{
		"Authorization":      authToken,
		"X-ACEP-ProductId":   "<your-product-id>",
		"X-ACEP-DeviceId":    "<your-device-id>",
		"X-ACEP-TosBucket":   "<your-tos-bucket>",
		"X-ACEP-TosRegion":   "<your-tos-region>",
		"X-ACEP-TosEndpoint": "<your-tos-endpoint>",
		"X-ACEP-TosSession":  "",
	})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	req := mcp.CallToolRequest{}
	req.Params.Name = "take_screenshot"
	req.Params.Arguments = map[string]interface{}{}

	result, err := cli.CallTool(ctx, req)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Screenshot result:", result)
}
```

**Note:** Replace placeholder values (e.g., `<your-product-id>`) with actual information. To call different tools, modify `req.Params.Name` and `req.Params.Arguments`.
```

--------------------------------

### CnchMergeTree Table with Compression Codecs Example

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_bytehouse/mcp_bytehouse/knowledge/cnch_merge_tree.md

This SQL statement demonstrates how to create a table with the CnchMergeTree engine and apply different compression codecs to individual columns. It showcases the use of default LZ4, LZ4HC, ZSTD, Delta, and NONE codecs. This example helps illustrate the practical application of compression configurations for optimizing storage and query performance.

```sql
CREATE TABLE codec_example
(
    date Date CODEC(Delta, ZSTD),
    ts DateTime CODEC(LZ4HC),
    float_value Float32 CODEC(NONE),
    double_value Float64 CODEC(LZ4HC(9))
)
ENGINE = CnchMergeTree
PARTITION BY tuple()
ORDER BY date

```

--------------------------------

### MCP Tool Discovery and Parameter Documentation (Python)

Source: https://context7.com/volcengine/mcp-server/llms.txt

This Python code demonstrates how to create and manage MCP server tools, including setting up parameter documentation for API actions like `describe_load_balancers` and `describe_listeners`. It utilizes a `FastMCP` class to register tools and provides functions for retrieving documentation and querying ALB instances.

```python
def create_mcp_server():
    service = AlbAPI()
    mcp = FastMCP("ALB MCP")

    # Store parameter documentation
    note = {
        "describe_load_balancers": """
        Parameters:
        - PageNumber (int, optional): Page number, default 1
        - PageSize (int, optional): Results per page, 1-100, default 20
        - LoadBalancerIds (list[str], optional): ALB instance ID list
        - LoadBalancerName (str, optional): Instance name filter
        - ProjectName (str, optional): Project name filter
        - Tags (list[dict], optional): Tag filters [{"Key": "env", "Value": "prod"}]

        Example:
        {
            "PageNumber": 1,
            "PageSize": 50,
            "Tags": [{"Key": "Environment", "Value": "Production"}]
        }
        """,
        "describe_listeners": """
        Parameters:
        - ListenerIds (list[str], optional): Listener ID list
        - LoadBalancerId (str, required): ALB instance ID
        - ListenerName (str, optional): Listener name filter
        - Protocol (str, optional): Protocol filter (HTTP/HTTPS/QUIC)
        """
    }

    @mcp.tool()
    def guide() -> str:
        """Get usage guide for MCP server"""
        return """
        Usage Guide:
        1. Call get_note(func_name) to retrieve parameter documentation
        2. Call the specific function with required parameters
        3. Parse JSON response for results
        """

    @mcp.tool()
    def get_note(func_name: str) -> str:
        """
        Get parameter documentation for a function

        Args:
            func_name: Function name to get docs for
        """
        return note.get(func_name, "No documentation available")

    @mcp.tool()
    def describe_load_balancers(params: dict) -> str:
        """Query ALB instance list"""
        return service.mcp_get("McpDescribeLoadBalancers", params, "{}")

    return mcp

```

--------------------------------

### Auto Install App on Cloud Phone

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README_en.md

Automatically downloads and installs an application on the cloud phone. This tool is designed for unattended app installation. Specific parameters for the app to be installed would be required in a full implementation.

```json
{
  "tool_name": "autoinstall_app",
  "parameters": {
    "app_url": "URL_to_app",
    "package_name": "com.example.app"
  }
}
```

--------------------------------

### Configure MCP Live Server with uvx (Git URL)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_live/README_zh.md

Configuration snippet for the MCP settings file to run the 'mcp-live' server using 'uvx' from a Git repository. It specifies the command, arguments pointing to the repository subdirectory, and environment variables for authentication.

```json
{
  "mcp-server": {
    "mcp-live": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_live",
        "mcp-server-live"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "your access-key-id",
        "VOLCENGINE_SECRET_KEY": "your access-key-secret",
        "VOLCENGINE_REGION": "your region"
      }
    }
  }
}
```

--------------------------------

### List Apps - Cloud Phone Tool

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README.md

Lists all installed applications on the cloud phone. This tool requires no input parameters. The output contains a list of applications, each with details like app ID, name, status, and package name.

```json
{
  "result": {
    "AppList": [
      {
        "app_id": "",
        "app_name": "抖音",
        "app_status": "undeployed",
        "package_name": "com.ss.android.ugc.aweme"
      }
    ]
  }
}
```

--------------------------------

### Configure MCP Live Server with uv (Run mcp-server-live)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_live/README_zh.md

Configuration snippet for the MCP settings file to run the 'mcp-live' server using 'uv'. It specifies the command, arguments, and environment variables required for authentication and region.

```json
{
  "mcpServers": {
    "mcp-live": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/mcp_server_live/src/live",
        "run",
        "mcp-server-live"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "your access-key-id",
        "VOLCENGINE_SECRET_KEY": "your access-key-secret",
        "VOLCENGINE_REGION": "your region"
      }
    }
  }
}
```

--------------------------------

### Install uv on Linux

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_cen/README.md

This snippet shows how to install uv on a Linux system using curl. uv is a fast Python package installer and virtual environment manager.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Deploy Enterprise MCP Server with UVX

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_enterprise/README.md

This JSON configuration demonstrates how to deploy the Enterprise Services MCP Server using the 'uvx' command. It specifies the source from a Git repository and includes environment variables for Volcengine API keys. Ensure you replace 'Your Volcengine AK' and 'Your Volcengine SK' with your actual credentials.

```json
{
  "mcpServers": {
    "mcp-server-enterprise": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_enterprise",
        "mcp-server-enterprise"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "Your Volcengine AK",
        "VOLCENGINE_SECRET_KEY": "Your Volcengine SK"
      }
    }
  }
}
```

--------------------------------

### Deploy Domain Service MCP Server with UVX

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_domain_service/README.md

This snippet shows how to deploy the Domain Service MCP Server using the 'uvx' command. It specifies the source from a Git repository and configures environment variables for Volcengine access keys.

```json
{
  "mcpServers": {
    "mcp-server-domain-service": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_domain_service",
        "mcp-server-domain-service"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "Your Volcengine AK",
        "VOLCENGINE_SECRET_KEY": "Your Volcengine SK"
      }
    }
  }
}
```

--------------------------------

### Auto Install App - Cloud Phone Tool

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README.md

Downloads and automatically installs an application on the cloud phone. It requires the application's 'download_url' and 'app_name'. The output indicates that the APK installation is in progress.

```json
{
  "result": "Apk is being installed"
}
```

--------------------------------

### Auto Install App

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README.md

Automatically downloads and installs a specified application on the cloud phone.

```APIDOC
## POST /autoinstall_app

### Description
Automatically downloads and installs a specified application on the cloud phone.

### Method
POST

### Endpoint
/autoinstall_app

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **app_name** (string) - Required - The name of the app to be installed.
- **download_url** (string) - Required - The download URL of the app.

### Request Example
```json
{
  "app_name": "ExampleApp",
  "download_url": "http://example.com/app.apk"
}
```

### Response
#### Success Response (200)
- **result** (string) - Message indicating that the app installation is in progress.

#### Response Example
```json
{
  "result": "Apk is being installed"
}
```
```

--------------------------------

### Run MCP Server Locally (Bash)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_vpn/README_zh.md

This snippet shows how to set environment variables required for the Volcengine MCP server, including access keys, region, and endpoint. It then demonstrates how to start the MCP server for VPN using the 'uv' command. Ensure VOLCENGINE_ACCESS_KEY and VOLCENGINE_SECRET_KEY are replaced with your actual credentials.

```bash
export VOLCENGINE_ACCESS_KEY=<your_ak>
export VOLCENGINE_SECRET_KEY=<your_sk>
export VOLCENGINE_REGION=cn-beijing
export VOLCENGINE_ENDPOINT=open.volcengineapi.com
export PORT=8000
uv run mcp-server-vpn
```

--------------------------------

### Configure MCP Live Server with uv (Run server.py)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_live/README_zh.md

Alternative configuration snippet for the MCP settings file to run the 'mcp-live' server using 'uv', directly executing 'server.py'. It includes command, arguments, and environment variables for authentication.

```json
{
  "mcpServers": {
    "mcp-live": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/mcp_server_live/src/live",
        "run",
        "server.py"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "your access-key-id",
        "VOLCENGINE_SECRET_KEY": "your access-key-secret",
        "VOLCENGINE_REGION": "your region"
      }
    }
  }
}
```

--------------------------------

### Put Logs V2 Tool Output Example

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_tls/README.md

An example of the output from the put_logs_v2_tool, which includes a 'request_id' for tracking the log upload operation.

```json
{
    "request_id": "your_request_id"
}
```

--------------------------------

### Configure MCP Live Server with uvx (Local Path)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_live/README_zh.md

Configuration snippet for the MCP settings file to run the 'mcp-live' server using 'uvx' from a local path. It specifies the command, arguments pointing to the local directory, and environment variables for authentication.

```json
{
  "mcpServers": {
    "mcp-live": {
      "command": "uvx",
      "args": [
        "--from",
        "/ABSOLUTE/PATH/TO/PARENT/mcp-server/server/mcp_server_live",
        "mcp-server-live"
      ],
      "env": {
        "VOLCENGINE_ACCESS_KEY": "your access-key-id",
        "VOLCENGINE_SECRET_KEY": "your access-key-secret",
        "VOLCENGINE_REGION": "your region"
      }
    }
  }
}
```

--------------------------------

### List Installed Apps - Go

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README_en.md

Retrieves a list of all installed applications on the device. This function does not require any input parameters.

```go
package main

import (
	"context"
	"log"

	"github.com/volcengine/volcengine-sdk-golang/service/mobile_use_client"
	"github.com/volcengine/volcengine-sdk-golang/service/mobile_use_client/mcp"
)

func main() {
	ctx := context.Background()
	// Path to the MCP Server executable file
	cmd := "./output/mobile_use_mcp"
	// Environment variables (replace with actual values)
	env := []string{
		"ACEP_ACCESS_KEY=<your-access-key>",
		"ACEP_SECRET_KEY=<your-secret-key>",
		"ACEP_PRODUCT_ID=<your-product-id>",
		"ACEP_DEVICE_ID=<your-device-id>",
		"TOS_ACCESS_KEY=<tos-access-key>",
		"TOS_SECRET_KEY=<tos-secret-key>",
		"ACEP_TOS_BUCKET=<tos-bucket>",
		"ACEP_TOS_REGION=<tos-region>",
		"ACEP_TOS_ENDPOINT=<tos-endpoint>",
	}
	args := []string{"--transport", "stdio"}
	cli, err := mobile_use_client.NewMobileUseStdioClient(ctx, cmd, env, args...)
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	req := mcp.CallToolRequest{}
	req.Params.Name = "list_apps"
	req.Params.Arguments = map[string]interface{}{
	}

	result, err := cli.CallTool(ctx, req)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("List apps result:", result)
}

```

--------------------------------

### Deploy MCP Server Cloud Assistant with UVX

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_cloud_assistant/README.md

Configuration for deploying the `mcp_server_cloud_assistant` using the `uvx` command. This method allows deployment directly from a Git repository, specifying environment variables for authentication.

```json
{
  "mcpServers": {
    "mcp_server_cloud_assistant": {
      "command": "uvx",
      "env": {
        "VOLC_ENDPOINT":"Volcengine OpenApi Endpoint",
        "VOLC_ACCESSKEY":"Your Volcengine access key",
        "VOLC_SECRETKEY":"Your Volcengine secret key"
      },
      "args": [
        "--from",
        "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_cloud_assistant",
        "mcp-server-cloud-assistant"
      ]
    }
  }
}
```

--------------------------------

### Start Mcp-Server with UV (SSE Mode)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README_zh.md

Starts the mcp-server-computer-use application using 'uv run' in SSE (Server-Sent Events) mode. This is an alternative to the default stdio mode.

```bash
uv run mcp-server-computer-use -t sse
```

--------------------------------

### Install UV Package Manager (Bash)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_cdn/README.md

Provides commands to install the UV package manager on Linux/macOS and Windows systems. UV is a requirement for running the CDN MCP Server.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Create DB Instance

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_rds_postgresql/README.md

Create an RDS PostgreSQL instance.

```APIDOC
## Create DB Instance

### Description
Create an RDS PostgreSQL instance.

### Method
POST

### Endpoint
/api/v1/db_instances

### Parameters
#### Request Body
- **instance_name** (string) - Required - The name for the new instance.
- **engine** (string) - Required - The database engine (e.g., "PostgreSQL").
- **engine_version** (string) - Required - The desired engine version.
- **instance_type** (string) - Required - The type of instance (e.g., "db.r6.large").
- **storage_size** (integer) - Required - The storage size in GB.
- **region** (string) - Required - The region for the instance.
- **password** (string) - Required - The password for the default 'postgres' user.

### Request Example
```json
{
  "query": "Create an RDS PostgreSQL instance",
  "parameters": {
    "instance_name": "my-new-rds",
    "engine": "PostgreSQL",
    "engine_version": "13.5",
    "instance_type": "db.r6.large",
    "storage_size": 100,
    "region": "cn-beijing",
    "password": "your_secure_password"
  }
}
```

### Response
#### Success Response (201)
- **instance_id** (string) - The ID of the newly created instance.

#### Response Example
```json
{
  "instance_id": "postgres-abcdef789"
}
```
```

--------------------------------

### List Installed Apps on Cloud Phone

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README_en.md

Retrieves a list of all installed applications on the cloud phone. This tool does not require any input parameters. The output will be a list of app package names or details.

```json
{
  "tool_name": "list_apps",
  "parameters": {}
}
```

--------------------------------

### Configure MCP Server IAM Local Run (JSON)

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_iam/README.md

This JSON configuration defines how to run the MCP Server for IAM locally using the 'uv' command. It specifies the command, arguments, and environment variables required for execution, including Volcengine API credentials.

```json
{
    "mcpServers": {
        "iam": {
            "command": "uv",
            "args": [
                "--directory",
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER",
                "run",
                "mcp-server-iam"
            ],
            "env": {
                "VOLCENGINE_ACCESS_KEY": "your ak",
                "VOLCENGINE_SECRET_KEY": "your sk",
                "VOLCENGINE_ACCESS_SESSION_TOKEN": "your session token"
          }
        }
    }
}
```

--------------------------------

### Run Mcp Server with uvx Configuration

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_computer_use/README.md

A JSON configuration object for running the Computer Use Mcp Server using `uvx`. This configuration specifies the git repository, subdirectory, command, arguments, and environment variables for the server.

```json
{
    "mcpServers": {
        "mcp-server-computer-use": {
            "command": "uvx",
            "args": [
            "--from",
            "git+https://github.com/volcengine/mcp-server#subdirectory=server/mcp_server_computer_use",
            "mcp-server-computer-use"
          ],
            "env": {
                "MCP_SERVER_PORT": 8000,
                "TOOL_SERVER_ENDPOINT": "{endpoint}"
            }
        }
    }
}
```

--------------------------------

### POST /list_apps

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_mobile_use/README_en.md

Lists all installed applications on the device.

```APIDOC
## POST /list_apps

### Description
Lists all installed applications on the device.

### Method
POST

### Endpoint
/list_apps

### Parameters
#### Request Body
(No specific parameters required for this request.)

### Request Example
```json
{
}
```

### Response
#### Success Response (200)
- **result** (object) - An object containing a list of installed applications.
  - **AppList** (array) - An array of application objects.
    - **app_id** (string) - The unique identifier of the application.
    - **app_name** (string) - The name of the application.
    - **app_status** (string) - The current status of the application (e.g., "undeployed").
    - **package_name** (string) - The package name of the application.

#### Response Example
```json
{
  "result": {
    "AppList": [
      {
        "app_id": "",
        "app_name": "抖音",
        "app_status": "undeployed",
        "package_name": "com.ss.android.ugc.aweme"
      }
    ]
  }
}
```
```

--------------------------------

### Describe Backups

Source: https://github.com/volcengine/mcp-server/blob/main/server/mcp_server_rds_postgresql/README.md

Get the list of backups for a specified RDS PostgreSQL instance.

```APIDOC
## Describe Backups

### Description
Get the list of backups for a specified RDS PostgreSQL instance.

### Method
GET

### Endpoint
/api/v1/db_instances/{instance_id}/backups

### Parameters
#### Path Parameters
- **instance_id** (string) - Required - The ID of the RDS PostgreSQL instance.

### Request Example
```json
{
  "query": "Get the backup list of the postgres-123456 instance"
}
```

### Response
#### Success Response (200)
- **backups** (array) - A list of backups.
  - **backup_id** (string) - The ID of the backup.
  - **backup_time** (string) - The time when the backup was created.
  - **status** (string) - The status of the backup.

#### Response Example
```json
{
  "backups": [
    {
      "backup_id": "bkp-abcdef123",
      "backup_time": "2023-10-27T10:00:00Z",
      "status": "COMPLETED"
    }
  ]
}
```
```