# Mcptools > A command-line interface for interacting with MCP (Model Context Protocol) servers using both stdio and HTTP transport. - **Type:** MCP server - **Install:** `agentstack add mcp-f-mcptools` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [f](https://agentstack.voostack.com/s/f) - **Installs:** 0 - **Category:** [Integrations](https://agentstack.voostack.com/c/integrations) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [f](https://github.com/f) - **Source:** https://github.com/f/mcptools ## Install ```sh agentstack add mcp-f-mcptools ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About Swiss Army Knife for MCP Servers 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. [](https://blog.fka.dev/blog/2025-03-27-mcp-inspector-vs-mcp-tools/) ## Table of Contents - [Overview](#overview) - [Difference Between the MCP Inspector and MCP Tools](https://blog.fka.dev/blog/2025-03-27-mcp-inspector-vs-mcp-tools/) - [Installation](#installation) - [Using Homebrew](#using-homebrew) - [From Source](#from-source) - [Getting Started](#getting-started) - [Features](#features) - [Transport Options](#transport-options) - [Output Formats](#output-formats) - [Commands](#commands) - [Interactive Shell](#interactive-shell) - [Web Interface](#web-interface) - [Project Scaffolding](#project-scaffolding) - [Server Aliases](#server-aliases) - [LLM Apps Config Management](#llm-apps-config-management) - [Server Modes](#server-modes) - [Mock Server Mode](#mock-server-mode) - [Proxy Mode](#proxy-mode) - [Guard Mode](#guard-mode) - [Examples](#examples) - [Basic Usage](#basic-usage) - [Script Integration](#script-integration) - [Debugging](#debugging) - [Contributing](#contributing) - [Roadmap](#roadmap) - [License](#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) ## Installation ### Using Homebrew (for macOS) ```bash 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) ```bash 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. > > > > 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: ```bash # 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: ``` 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. ``` ### 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. ```bash 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`. ```bash 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. ```bash # 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) ```bash 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 ``` Key features of the format: - Function names are displayed in bold cyan - Required parameters are shown in green (e.g., `path:str`) - Optional parameters are shown in yellow brackets (e.g., `[limit:int]`) - Array types are indicated with `[]` suffix (e.g., `str[]`) - Object types show their properties in curly braces (e.g., `{prop1:type1,prop2:type2}`) - Nested objects are displayed recursively (e.g., `{notifications:{enabled:bool,sound:bool}}`) - Type names are shortened for readability (e.g., `str` instead of `string`, `int` instead of `integer`) - Descriptions are indented and displayed in gray - Parameter order is consistent, with required parameters listed first #### JSON Format (Compact) ```bash mcp tools --format json npx -y @modelcontextprotocol/server-filesystem ~ ``` #### Pretty JSON Format (Indented) ```bash mcp tools --format pretty npx -y @modelcontextprotocol/server-filesystem ~ ``` ### Commands MCP Tools includes several core commands for interacting with MCP servers: #### List Available Tools ```bash mcp tools npx -y @modelcontextprotocol/server-filesystem ~ ``` #### List Available Resources ```bash mcp resources npx -y @modelcontextprotocol/server-filesystem ~ ``` #### List Available Prompts ```bash mcp prompts npx -y @modelcontextprotocol/server-filesystem ~ ``` #### Call a Tool ```bash mcp call read_file --params '{"path":"/path/to/file"}' npx -y @modelcontextprotocol/server-filesystem ~ ``` #### Call a Resource ```bash mcp call resource:test://static/resource/1 npx -y @modelcontextprotocol/server-everything -f json | jq ".contents[0].text" ``` or ```bash mcp read-resource test://static/resource/1 npx -y @modelcontextprotocol/server-everything -f json | jq ".contents[0].text" ``` #### Call a Prompt ```bash mcp get-prompt simple_prompt npx -y @modelcontextprotocol/server-everything -f json | jq ".messages[0].content.text" ``` #### Viewing Server Logs When using client commands that make calls to the server, you can add the `--server-logs` flag to see the server logs related to your request: ```bash # View server logs when listing tools 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. ### Interactive Shell The interactive shell mode allows you to run multiple MCP commands in a single session: ```bash mcp shell npx -y @modelcontextprotocol/server-filesystem ~ ``` This opens an interactive shell with the following capabilities: ``` mcp tools shell connected to: npx -y @modelcontextprotocol/server-filesystem /Users/fka mcp > Type '/h' for help or '/q' to quit mcp > tools read_file(path:str, [limit:int], [offset:int]) Reads a file from the filesystem list_dir(path:str) Lists directory contents 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 # Direct tool calling is supported mcp > read_file {"path":"README.md"} ...content of README.md... # Calling a tool with complex object parameters mcp > edit_file {"path":"main.go","edits":[{"oldText":"foo","newText":"bar"}]} ...result of edit operation... # Get help mcp > /h MCP Shell Commands: tools List available tools resources List available resources prompts List available prompts call [--params '{...}'] Call a tool, resource, or prompt format [json|pretty|table] Get or set output format Special Commands: /h, /help Show this help /q, /quit, exit Exit the shell ``` ### Web Interface MCP Tools provides a web interface for interacting with MCP servers through a browser-based UI: ```bash # Start a web interface for a filesystem server on default port (41999) mcp web npx -y @modelcontextprotocol/server-filesystem ~ # Use a custom port mcp web --port 8080 docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server # Use SSE mcp web https://ne.tools ``` The web interface includes: - A sidebar listing all available tools, resources, and prompts - Form-based and JSON-based parameter editing - Formatted and raw JSON response views - Interactive parameter forms automatically generated from tool schemas - Support for complex parameter types (arrays, objects, nested structures) - Direct API access for tool calling Once started, you can access the interface by opening `http://localhost:41999` (or your custom port) in a browser. ### Project Scaffolding MCP Tools provides a scaffolding feature to quickly create new MCP servers with TypeScript: ```bash mkdir my-mcp-server cd my-mcp-server # Create a project with specific components mcp new tool:calculate resource:file prompt:greet # Create a project with a specific SDK (currently only TypeScript/ts supported) mcp new tool:calculate --sdk=ts # Create a project with a specific transport type mcp new tool:calculate --transport=stdio mcp new tool:calculate --transport=sse ``` The scaffolding creates a complete project structure with: - Server setup with chosen transport (stdio or SSE) - TypeScript configuration with modern ES modules - Component implementations with proper MCP interfaces - Automatic wiring of imports and initialization After scaffolding, you can build and run your MCP server: ```bash # Install dependencies npm install # Build the TypeScript code npm run build # Test the server with MCP Tools 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`. ## Server Aliases MCP Tools allows you to save and reuse server commands with friendly aliases: ```bash # Add a new server alias mcp alias add myfs npx -y @modelcontextprotocol/server-filesystem ~/ # List all registered server aliases mcp alias list # Remove a server alias mcp alias remove myfs # Use an alias with any MCP command mcp tools myfs mcp call read_file --params '{"path":"README.md"}' myfs ``` Server aliases are stored in `$HOME/.mcpt/aliases.json` and provide a convenient way to work with commonly used MCP servers without typing long commands repeatedly. ## LLM Apps Config Management 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 # Scan for MCP server configurations across all supported applications mcp configs scan # List all configurations (alias for configs view --all) mcp configs ls # View specific configuration by alias mcp configs view vscode # Add or update a server in a configuration 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" # Add to multiple configurations at once mcp configs set vscode,cursor,claude-desktop my-server npm run mcp-server # Remove a server from a configuration mcp configs remove vscode my-server # Create an alias for a custom config file mcp configs alias myapp ~/myapp/config.json # Synchronize and merge configurations from multiple sources mcp configs sync vscode cursor --output vscode --default interactive # Convert a command line to MCP server JSON configuration format mcp configs as-json mcp proxy start # Output: {"command":"mcp","args":["proxy","start"]} # Convert a URL to MCP server JSON configuration format mcp configs as-json https://api.example.com/mcp --headers "Authorization=Bearer token" # Output: {"url":"https://api.example.com/mcp","headers":{"Authorization":"Bearer token"}} ``` Configurations are managed through a central registry in `$HOME/.mcpt/configs.json` with predefined aliases for: - VS Code and VS Code Insiders - Windsurf - Cursor - Claude Desktop and Claude Code The system automatically displays server configurations in a colorized format grouped by source, showing command-line or URL information, headers, and environment variables. `mcp configs scan` command looks for MCP server configurations in: - Visual Studio Code - Visual Studio Code Insiders - Windsurf - Cursor - Claude Desktop Example Output: ``` VS Code Insiders GitHub (stdio): docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server Claude Desktop Proxy (stdio): mcp proxy start My Files (stdio): npx -y @modelcontextprot … ## Source & license This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [f](https://github.com/f) - **Source:** [f/mcptools](https://github.com/f/mcptools) - **License:** MIT Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/mcp-f-mcptools - Seller: https://agentstack.voostack.com/s/f - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.