Swiss Army Knife for MCP Servers

by f

1.6k 525 downloads Not rated yet MIT

GitHub

Other

About

A command-line interface for interacting with MCP (Model Context Protocol) servers using both stdio and HTTP transport.

Details

License: MIT

Explore

MCP Tools supports a wide range of features for interacting with MCP servers:

Usage: mcp [command] Available Commands: version Print the version information tools List available tools on the MCP server resources List available resources on the MCP server prompts List available prompts on the MCP server call Call a tool, resource, or prompt on the MCP server get-prompt Get a prompt on the MCP server read-resource Read a resource on the MCP server shell Start an interactive shell for MCP commands web Start a web interface for MCP commands mock Create a mock MCP server with tools, prompts, and resources proxy Proxy MCP tool requests to shell scripts alias Manage MCP server aliases configs Manage MCP server configurations new Create a new MCP project component help Help about any command completion Generate the autocompletion script for the specified shell Flags: -f, --format string Output format (table, json, pretty) (default "table") -h, --help help for mcp -p, --params string JSON string of parameters to pass to the tool (for call command) (default "{}")

Use "mcp [command] --help" for more information about a command.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Swiss Army Knife for MCP Servers

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

From the repository

The simplest way to start using MCP Tools is to connect to an MCP server and list available tools:

npm install MCP Tools provides a powerful configuration management system that helps you work with MCP server configurations across multiple applications: > 🚧 This works only on macOS for now.

bash

mcp configs scan

mcp configs ls

mcp configs view vscode

mcp configs set vscode my-server npm run mcp-server
mcp configs set cursor my-api https://api.example.com/mcp --headers "Authorization=Bearer token"

mcp configs set vscode,cursor,claude-desktop my-server npm run mcp-server

mcp configs remove vscode my-server

mcp configs alias myapp ~/myapp/config.json

mcp configs sync vscode cursor --output vscode --default interactive

mcp configs as-json mcp proxy start

mcp configs as-json https://api.example.com/mcp --headers "Authorization=Bearer token"

if [ -z "$a" ] || [ -z "$b" ]; then
echo "Error: Missing required parameters 'a' or 'b'"
exit 1
fi

- Tools are registered in ~/.mcpt/proxy_config.json
- The proxy server logs all requests and responses to ~/.mcpt/logs/proxy.log
- Use --unregister to remove a tool from the configuration

List tools from a filesystem server:

mcp tools npx -y @modelcontextprotocol/server-filesystem ~

Call a tool with pretty JSON output:

mcp call read_file --params '{"path":"README.md"}' --format pretty npx -y @modelcontextprotocol/server-filesystem ~

Use the guard mode to filter available tools:


mcp guard --deny tools:write_,delete_,create_,move_ npx -y @modelcontextprotocol/server-filesystem ~

Create and run a local streamable HTTP server:

npm install && npm run build

mcp tools https://authenticated-mcp-server.com

mcp tools npx -y @modelcontextprotocol/server-filesystem ~

mcp call read_file --params '{"path":"README.md"}' npx -y @modelcontextprotocol/server-filesystem ~

mcp tools npx -y @modelcontextprotocol/server-filesystem ~

mcp call read_file --params '{"path":"/path/to/file"}' npx -y @modelcontextprotocol/server-filesystem ~

mcp tools --server-logs npx -y @modelcontextprotocol/server-filesystem ~



Output:

[>] Secure MCP Filesystem Server running on stdio
[>] Allowed directories: [ '/Users/fka/' ]
read_file(path:str)
Read the complete contents of a file from the file system.
read_multiple_files(paths:str[])
Read the contents of multiple files simultaneously.
... and the other tools available on this server



This can be helpful for debugging or understanding what's happening on the server side when executing these commands.
mcp > read_file {"path":"README.md"}

...content of README.md...
mcp > edit_file {"path":"main.go","edits":[{"oldText":"foo","newText":"bar"}]}

...result of edit operation...
mcp tools node build/index.js

Project templates are stored in either:
- Local ./templates/ directory
- User's home directory: ~/.mcpt/templates/
- Homebrew installation path (/opt/homebrew/Cellar/mcp/v#.#.#/templates)

When installing via Homebrew, templates are automatically installed to your home directory. But if you use source install, you need to run make install-templates.

mcp mock tool hello_world "A simple greeting tool"

mcp proxy tool add_operation "Adds a and b" "a:int,b:int" ./examples/add.sh

mcp proxy tool add_operation "Adds a and b" "a:int,b:int" -e 'echo "total is $a + $b = $(($a+$b))"'

mcpt proxy tool add_operation "Adds a and b with optional result msg" "a:int,b:int,[msg:string]" -e 'echo "$msg$a + $b = $(($a+$b))"'

mcp proxy tool --unregister add_operation

mcp proxy tool qrcode "Generates a QR code" "text:string" \
-e 'echo -e "data:image/png;base64,$(qrencode -t png -o - "$text" | base64 -w 0)"'

Inline Command Example:

bash

mcp guard --allow 'tools:search_files' npx -y @modelcontextprotocol/server-filesystem ~

mcp guard --allow 'tools:read_,prompts:system_' --deny tools:execute_* npx -y @modelcontextprotocol/server-filesystem ~

mcp call example_tool --params '{"input": "test"}' http://localhost:3000/sse

mcp proxy tool add_numbers "Adds two numbers" "a:int,b:int" ./add.sh

mcp call add_numbers --params '{"a":5,"b":3}' --format pretty
```

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "swiss army knife for mcp servers": {
            "mcptools": {
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                ]
            }
        }
    }
}

McpServers

{
    "mcptools": {
        "command": "docker",
        "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
        ]
    }
}

<h1 align="center">Swiss Army Knife for MCP Servers</h1>

A comprehensive command-line interface for interacting with MCP (Model Context Protocol) servers.
 
Discover, call, and manage tools, resources, and prompts from any MCP-compatible server.
 
Supports multiple transport methods, output formats, and includes powerful mock and proxy server capabilities.

- Overview
- Difference Between the MCP Inspector and MCP Tools
- Installation
- Using Homebrew
- From Source
- Getting Started
- Features
- Transport Options
- Output Formats
- Commands
- Interactive Shell
- Web Interface
- Project Scaffolding
- Server Aliases
- LLM Apps Config Management
- Server Modes
- Mock Server Mode
- Proxy Mode
- Guard Mode
- Examples
- Basic Usage
- Script Integration
- Debugging
- Contributing
- Roadmap
- License

Overview

MCP Tools provides a versatile CLI for working with Model Context Protocol (MCP) servers. It enables you to:

- Discover and call tools provided by MCP servers
- Access and utilize resources exposed by MCP servers
- Create mock servers for testing client applications
- Proxy MCP requests to shell scripts for easy extensibility
- Create interactive shells for exploring and using MCP servers
- Scaffold new MCP projects with TypeScript support
- Format output in various styles (JSON, pretty-printed, table)
- Guard and restrict access to specific tools and resources
- Support all transport methods (HTTP, stdio)

MCP Tools Screenshot

Installation

Using Homebrew (for macOS)

brew tap f/mcptools
brew install mcp

> ❕ The binary is installed as mcp but can also be accessed as mcpt to avoid conflicts with other tools that might use the mcp command name.

From Source (for Windows and GNU/Linux)

go install github.com/f/mcptools/cmd/mcptools@latest

> ❕ The binary will be installed as mcptools when but can be aliased to mcpt for convenience.
>
> Screenshot 2025-05-05 at 22 21 29
>
> Windows 11 Running Example

Getting Started

The simplest way to start using MCP Tools is to connect to an MCP server and list available tools:

# List all available tools from a filesystem server
mcp tools npx -y @modelcontextprotocol/server-filesystem ~
Call a specific tool
mcp call read_file --params '{"path":"README.md"}' npx -y @modelcontextprotocol/server-filesystem ~
Open an interactive shell
mcp shell npx -y @modelcontextprotocol/server-filesystem ~

Features

MCP Tools supports a wide range of features for interacting with MCP servers:

Use "mcp [command] --help" for more information about a command.

Transport Options

MCP Tools supports multiple transport methods for communicating with MCP servers:

Stdio Transport

Uses stdin/stdout to communicate with an MCP server via JSON-RPC 2.0. This is useful for command-line tools that implement the MCP protocol.

mcp tools npx -y @modelcontextprotocol/server-filesystem ~

HTTP SSE Transport

Uses HTTP and Server-Sent Events (SSE) to communicate with an MCP server via JSON-RPC 2.0. This is useful for connecting to remote servers that implement the legacy MCP protocol. Transport is automatically detected when the URL ends with /sse.

mcp tools http://localhost:3001/sse
Example: Use the everything sample server
docker run -p 3001:3001 --rm -it tzolov/mcp-everything-server:v1

_Note:_ HTTP SSE currently supports only MCP protocol version 2024-11-05.

Streamable HTTP Transport (Recommended)

Uses streamable HTTP to communicate with an MCP server via JSON-RPC 2.0. This is the modern, recommended approach for connecting to remote servers that implement the MCP protocol. It supports both streaming responses and simple request/response patterns. This is the default transport for HTTP/HTTPS URLs.

# Default transport for HTTP URLs
mcp tools http://localhost:3000
Streamable HTTP transport (auto-detected from URL)
mcp tools http://localhost:3000
Examples with remote servers
mcp tools https://api.example.com/mcp
mcp tools https://ne.tools

_Benefits of Streamable HTTP:_
- Session Management: Supports stateful connections with session IDs
- Resumability: Can reconnect and resume interrupted sessions (when supported by server)
- Flexible Responses: Supports both streaming and direct JSON responses
- Modern Protocol: Uses the latest MCP transport specification

Output Formats

MCP Tools supports three output formats to accommodate different needs:

Table Format (Default)

mcp tools npx -y @modelcontextprotocol/server-filesystem ~

The default format now displays tools in a colorized man-page style:

read_file(path:str)
     Read the complete contents of a file from the file system.
read_multiple_files(paths:str[])
     Read the contents of multiple files simultaneously.
list_dir(path:str)
     Lists the contents of a directory.
write_file(path:str, content:str)
     Writes content to a file.
grep_search(pattern:str, [excludePatterns:str[]])
     Search files with pattern.
edit_file(edits:{newText:str,oldText:str}[], path:str)
     Edit a file with multiple text replacements

…

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Explore

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Table of Contents

Overview

Installation

Using Homebrew (for macOS)

From Source (for Windows and GNU/Linux)

Getting Started

Call a specific tool

Open an interactive shell

Features

Transport Options

Stdio Transport

HTTP SSE Transport

Example: Use the everything sample server

docker run -p 3001:3001 --rm -it tzolov/mcp-everything-server:v1

Streamable HTTP Transport (Recommended)

Streamable HTTP transport (auto-detected from URL)

Examples with remote servers

Output Formats

Table Format (Default)

Videos about Swiss Army Knife for MCP Servers

CLI Swiss Army Knife for MCP Servers

Building Custom MCP Tools in PowerShell Universal

MCP Tools in TYPO3 verwenden: AI-Aktionen mit T3AF

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive