An MCP server that exposes 69 developer tools to any MCP-compatible LLM client — file I/O, shell execution, search, system info, and interactive user dialogs.

Communication happens over stdio using the mark3labs/mcp-go library.

• 69 tools, one binary — covers file ops, search, shell, system, HTTP, clipboard, user interaction, and Binance USDT-M Futures trading Disable any tool group you don't need with --disable=binance,user,... (see Disabling tool groups).
• Binance USDT-M Futures — market data, account/position queries, leverage/margin config, and gated trading (single + bracket orders) with browser-confirm dialogs and AI-supplied reasoning
• Built-in server instructions — the AI receives a categorized guide on when and how to use each tool
• Interactive dialogs — ask_user opens a browser dialog with choices, markdown, live updates, and typing indicators
• Cross-platform — macOS, Windows, and Linux (user dialogs require macOS/Windows; notify_user works everywhere)
• Surgical editing — edit_file with near-miss probe, CRLF transparency, batch mode, and regex support
• Performance-first — batch tools (read_multiple_files, write_multiple_files, path_exists_batch, get_multiple_file_info, edit_file batch mode) reduce round-trips

Grab a pre-built binary from the Releases page.

Claude Desktop — add to claude_desktop_config.json:

{
  "mcpServers": {
    "bmcptools": {
      "command": "/absolute/path/to/bmcptools"
    }
  }
}

Cursor / Copilot / other clients — point the command field at the same binary path.

Don't need every group? Pass --disable=GROUPS (CSV) when launching the binary, or set the BMCPTOOLS_DISABLE env var. The flag wins when both are set.

# Drop Binance and the interactive user prompts
bmcptools --disable=binance,user

# Same via env (handy in MCP client configs)
BMCPTOOLS_DISABLE=binance bmcptools

# List valid group names
bmcptools --list-groups

Available groups: user, file, multi, dir, search, exec, system, binance. The server instructions sent to the LLM are auto-trimmed to match — disabled sections are removed so the model isn't told about tools it can't see.

For Claude Desktop / Cursor configs:

{
  "mcpServers": {
    "bmcptools": {
      "command": "/absolute/path/to/bmcptools",
      "args": ["--disable=binance"]
    }
  }
}

Lets an MCP-connected LLM analyze the market and execute leveraged trades on Binance USDT-M Futures (fapi.binance.com). Read-only market-data tools work without credentials; account/config/trading tools require API key + secret. Mutating tools open a browser confirm dialog (via pkg/confirm) and require the AI to pass a reasoning string. Set BINANCE_SKIP_ASK_USER=true for full autonomy.

Environment variables

Market data — no auth (12)

Account & positions — auth required (7)

Account configuration — mutating, gated (3)

Trading — mutating, gated (6)

Safety model

• Mutating tools build a markdown trade brief (mark price, free margin, current positions, est. notional, SL/TP %, R:R, AI reasoning) and require user Approve in a browser dialog.
• Auto time-sync against /fapi/v1/time (-1021 triggers re-sync + retry).
• HTTP 503 Unknown error on order placement is never blind-retried — the tool reconciles via origClientOrderId before reporting success or asking the user to verify.
• Every response includes a [rate-limit] used_weight_1m=… order_count_1m=… footer so the AI can self-throttle.

Testnet caveats

• Base URL: https://testnet.binancefuture.com.
• STOP_MARKET, TAKE_PROFIT_MARKET, and TRAILING_STOP_MARKET are not supported on Futures testnet (returns -4120). As a result, place_bracket_order cannot fully execute on testnet — the entry leg places fine, but the SL / TP legs will fail and the tool will roll back. Use mainnet (with the smallest allowed notional) to validate brackets end-to-end, or simulate SL/TP with conditional STOP / TAKE_PROFIT limit orders on testnet.
• /futures/data/* (long/short ratio, open-interest history) returns HTTP 202 with empty body on testnet — this is a testnet limitation, not a tool bug.

Requirements: Go 1.23+

# Build binary into ./bin/
make build

# Build and stamp with a version tag
make build VERSION=v1.2.3

# Install into $GOBIN
make install VERSION=v1.2.3

# Run tests (root + all internal sub-packages)
make test
# or directly:
go test ./...

# Run linter (requires golangci-lint)
make lint

On Linux/macOS/Windows, make build auto-detects the version from git describe. Pass VERSION=<tag> explicitly to override it, or build without git tags and it will default to "dev".

The codebase follows a modular layout. Public APIs live under pkg/ (importable by external repos); internal implementation lives under internal/.

bmcptools/                     ← public API (server.go, registrar.go, toolnames.go)
├── cmd/bmcptools/             ← package main (entry point)
├── scripts/preview/           ← browser UI preview helper
├── pkg/
│   ├── browser/               ← shared HTTP server + browser-open infrastructure
│   ├── confirm/               ← standalone blocking confirm/cancel dialog
│   ├── connector/             ← Connector interface for external tool groups
│   ├── dialog/                ← HTML template contract types (DialogTemplate, RestTemplate)
│   ├── toolname/              ← public tool name constants (importable by connectors)
│   └── toolreg/               ← public ToolRegistrar interface
└── internal/
    ├── asset/                 ← embedded JSON descriptions + HTML/CSS/JS templates
    │   └── descriptions/      ← tool descriptions (JSON) + server instructions (TXT)
    ├── helper/                ← shared utilities (fs, read, diff, edit, mime, glob, checksum)
    └── tool/
        ├── dir/               ← directory tools
        ├── exec/              ← exec / process tools
        ├── file/              ← file read/write/edit tools
        ├── multi/             ← multi-file tools
        ├── search/            ← search & grep tools
        ├── system/            ← system info, HTTP, clipboard, processes
        ├── user/              ← interactive UI tools (ask, notify, rest)
        └── binance/           ← Binance USDT-M Futures (market data + signed trading)

import bmcptools "github.com/bearaujus/bmcptools"

s := server.NewMCPServer(bmcptools.ServerName, bmcptools.Version,
    server.WithInstructions(bmcptools.ServerInstructions()),
)

bmcptools.Register(s)                         // all tool groups, default HTML
bmcptools.Register(s, bmcptools.WithUserOptions(
    bmcptools.UserWithDialogTemplate(myDialogTmpl),  // custom ask_user HTML
))

import "github.com/bearaujus/bmcptools/pkg/toolname"

bmcptools.Register(s, bmcptools.WithExcludeTools(
    toolname.CompressFiles,
    toolname.ExtractArchive,
    toolname.CreateSymlink,
))

// Skip Binance + interactive user-dialog tools entirely.
// ServerInstructionsExcludingGroups trims the AI prompt to match.
s := server.NewMCPServer(bmcptools.ServerName, bmcptools.Version,
    server.WithInstructions(bmcptools.ServerInstructionsExcludingGroups(
        bmcptools.GroupBinance, bmcptools.GroupUser,
    )),
)

bmcptools.Register(s, bmcptools.WithDisableGroups(
    bmcptools.GroupBinance,
    bmcptools.GroupUser,
))

// Register only the groups you need, with scoped instructions
s := server.NewMCPServer(bmcptools.ServerName, bmcptools.Version,
    server.WithInstructions(bmcptools.ServerInstructionsForGroups("file", "search")),
)

bmcptools.RegisterFile(s)
bmcptools.RegisterSearch(s)

import (
    bmcptools "github.com/bearaujus/bmcptools"
    "github.com/bearaujus/bmcptools/pkg/connector"
)

// Your connector implements connector.Connector:
//   Name() string
//   Register(s toolreg.ToolRegistrar)
bmcptools.RegisterConnectors(s, larkConnector, slackConnector)

import "github.com/bearaujus/bmcptools/pkg/dialog"

tmpl, err := dialog.NewDialogTemplate(myHTML) // validated at construction
if err != nil { ... }

bmcptools.RegisterUser(s, bmcptools.UserWithDialogTemplate(tmpl))

Each internal/tool/<name>/ package exports a single Register(s toolreg.ToolRegistrar) function. The root Register(s ToolRegistrar) delegates to all of them.

The browser-based tools (ask_user, rest) and the destructive-operation confirm dialog use embedded HTML templates under internal/asset/html/. To preview them locally without running the full MCP server:

# Preview all pages (opens in your default browser)
go run ./scripts/preview

# Preview a specific page
go run ./scripts/preview dialog
go run ./scripts/preview rest
go run ./scripts/preview confirm

Pushing a tag (v*) triggers the release workflow, which cross-compiles for all platforms and publishes a GitHub release:

The release binaries are not code-signed, so your OS may show a security warning on first run. This is normal for open-source CLI tools distributed as standalone binaries.

Verify integrity first — each release includes a checksums.txt file with SHA256 hashes:

# macOS / Linux
sha256sum -c checksums.txt

# Windows (PowerShell)
Get-FileHash bmcptools.exe -Algorithm SHA256
# Compare the output with the hash in checksums.txt

Then unblock the binary:

All packages under pkg/ are considered stable public API:

Root-level exports in server.go, registrar.go, and toolnames.go are also stable. Packages under internal/ are not part of the public API and may change without notice.

See CONTRIBUTING.md for guidelines on adding new tools, project conventions, and known MCP SDK limitations.