TurboMCP Studio

A native desktop application for developing, testing, and debugging Model Context Protocol servers.

Download • Documentation • Contributing

---

Why TurboMCP Studio?

• Native Performance — Built with Rust and Tauri 2.0 for a fast, native desktop experience
• Multi-Transport — STDIO, HTTP/SSE, WebSocket, TCP, and Unix socket support out of the box
• Protocol Inspector — Real-time message tracing with latency tracking and filtering
• OAuth 2.1 Built-in — PKCE, token refresh, and provider templates for secured MCP servers
• Sampling & Elicitation — Human-in-the-loop approval for LLM sampling requests
• Cross-Platform — macOS, Windows, and Linux from a single codebase (Unix sockets on macOS/Linux, TCP/HTTP/WebSocket everywhere)
• MCP Proxy — Transparent proxy with transport bridging (STDIO ↔ HTTP ↔ WebSocket ↔ TCP)
• Benchmarking — Per-call instrumentation with latency percentiles, token estimation, and A/B comparison
• Developer-Friendly — Think Postman, but for MCP servers

Quick Start

1. Download the latest release for your platform
2. Install and launch TurboMCP Studio
3. Connect to your MCP server
4. Explore tools, resources, and prompts
5. Test your MCP implementation

Features

Server Management

• Connect to MCP servers over STDIO, HTTP/SSE, WebSocket, TCP, or Unix sockets
• Profile-based configuration with server groups and persistence
• Health monitoring with automatic reconnection and status tracking
• Rate limiting (configurable per-server) to protect upstream services

Developer Tools

• Tool Explorer — Discover, inspect, and invoke MCP tools with schema validation
• Resource Browser — Navigate and inspect MCP resources with content preview
• Prompt Designer — Create and test MCP prompts with variable interpolation
• Protocol Inspector — Real-time message tracing with request/response correlation and latency
• Developer Console — Integrated logging with level filtering

MCP Proxy & Benchmarking

• Transparent Proxy — Sit between any MCP client (Claude, etc.) and server, inspect all traffic
• Transport Bridging — Bridge different transports (e.g., expose a STDIO server over HTTP)
• Per-Call Metrics — Latency (min/P50/P95/P99/max), request/response bytes, estimated tokens
• Per-Tool Breakdown — Identify which tools are expensive with detailed statistics
• Per-Method Analysis — Aggregate metrics by RPC method (tools/list, tools/call, etc.)
• Benchmark Sessions — Start/stop instrumented sessions, generate JSON reports
• Report Comparison — A/B compare benchmark runs with delta analysis (latency, throughput, success rates)
• Live Feed — Real-time stream of call records with auto-scroll and filtering

Sampling & Elicitation

• Human-in-the-loop approval flow for MCP sampling requests
• Configurable auto-approve, manual, and LLM-assisted modes
• Cost estimation and request history tracking
• Elicitation support for structured user input from MCP servers

OAuth 2.1

• Built-in OAuth flow with PKCE (S256) support
• Provider templates for common OAuth servers
• Secure credential storage via OS keyring (macOS Keychain, Windows Credential Manager, Linux Secret Service)
• Token refresh and session management

Workflow Engine

• Define multi-step workflows against MCP servers
• Variable interpolation across steps
• Execution history with database persistence

Additional

• Light/dark theme with system preference detection
• Server registry browser for discovering MCP servers
• Collections for organizing and replaying MCP operations
• SQLite-backed local storage for history and configuration

Installation

Pre-built Binaries

Download the latest release for your platform from GitHub Releases:

Platform	Format
macOS (Apple Silicon)	.dmg or .app (signed + notarized)
macOS (Intel)	.dmg or .app (signed + notarized)
Windows	.msi installer
Linux	.AppImage or .deb

Building from Source

Prerequisites

All Platforms

• Node.js: 20.x or later (Download)
• pnpm: 9.x or later

  npm install -g pnpm
  

• Rust: 1.80 or later (rustup.rs) — Tauri 2.0 requires 1.77.2+

  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  

macOS

• Xcode Command Line Tools:

  xcode-select --install
  

Windows

• Visual Studio Build Tools: Download
  • Install "Desktop development with C++" workload
• WebView2: Usually pre-installed on Windows 10/11
  • If missing: Download WebView2 Runtime

Linux (Debian/Ubuntu)

sudo apt-get update
sudo apt-get install -y \
  libwebkit2gtk-4.1-dev \
  build-essential \
  curl \
  wget \
  file \
  libxdo-dev \
  libssl-dev \
  libayatana-appindicator3-dev \
  librsvg2-dev

Linux (Fedora/RHEL)

sudo dnf install -y \
  webkit2gtk4.1-devel \
  openssl-devel \
  curl \
  wget \
  file \
  libappindicator-gtk3-devel \
  librsvg2-devel

Clone the Repository

git clone https://github.com/Epistates/turbomcpstudio.git
cd turbomcpstudio

Install Dependencies

# Install frontend dependencies
pnpm install

TurboMCP v3.1.5 is published to crates.io and fetched automatically during the build process. No additional setup required.

Development Build

# Start development server with hot-reload
pnpm run tauri dev

# This will:
# 1. Start Vite dev server (frontend) on http://localhost:1420
# 2. Compile Rust backend
# 3. Launch desktop app with hot-reload enabled

Production Build

Quick Build (Local Testing)

For local testing without creating installers:

# macOS: Build app bundle only (faster, no DMG)
pnpm run tauri:build

# All platforms: Build executable without installers
pnpm run tauri build -- --no-bundle

# Executable location: src-tauri/target/release/turbomcpstudio(.exe)

Platform-Specific Builds

# Build for your current architecture
pnpm run tauri build

# Build for specific architecture
pnpm run tauri build -- --target aarch64-apple-darwin  # Apple Silicon
pnpm run tauri build -- --target x86_64-apple-darwin   # Intel

# Output locations:
# - App Bundle: src-tauri/target/[arch]/release/bundle/macos/TurboMCP Studio.app
# - DMG Installer: src-tauri/target/[arch]/release/bundle/dmg/TurboMCP Studio_*.dmg

Note: Unsigned builds will show a Gatekeeper warning. To bypass:

# Right-click app → "Open" → "Open"
# Or remove quarantine attribute:
xattr -d com.apple.quarantine "TurboMCP Studio.app"

# Build installers (MSI and NSIS)
pnpm run tauri build

# Build MSI only
pnpm run tauri build -- --bundles msi

# Build NSIS installer only
pnpm run tauri build -- --bundles nsis

# Output locations:
# - MSI: src-tauri/target/release/bundle/msi/TurboMCP Studio_*.msi
# - NSIS: src-tauri/target/release/bundle/nsis/TurboMCP Studio_*-setup.exe
# - Executable: src-tauri/target/release/turbomcpstudio.exe

Requirements:

• MSI requires WiX Toolset v3
• NSIS requires NSIS

Installation via Package Manager:

# Using Chocolatey
choco install wixtoolset nsis

# Using Scoop
scoop install wixtoolset nsis

# Build all Linux formats (AppImage, DEB, RPM)
pnpm run tauri build

# Build specific format
pnpm run tauri build -- --bundles appimage  # Universal format
pnpm run tauri build -- --bundles deb       # Debian/Ubuntu
pnpm run tauri build -- --bundles rpm       # Fedora/RHEL

# Output locations:
# - AppImage: src-tauri/target/release/bundle/appimage/turbomcp-studio_*.AppImage
# - DEB: src-tauri/target/release/bundle/deb/turbomcp-studio_*.deb
# - RPM: src-tauri/target/release/bundle/rpm/turbomcp-studio-*.rpm

Running AppImage:

chmod +x turbomcp-studio_*.AppImage
./turbomcp-studio_*.AppImage

Installing DEB:

sudo dpkg -i turbomcp-studio_*.deb
# If dependencies missing:
sudo apt-get install -f

Installing RPM:

sudo rpm -i turbomcp-studio-*.rpm
# Or with dnf:
sudo dnf install turbomcp-studio-*.rpm

Build Notes

• macOS: Unsigned builds will show a Gatekeeper warning (see Runtime Issues below for bypass)
• Windows: MSI creation requires WiX Toolset, NSIS installer requires NSIS
• Linux: AppImage requires FUSE, or use DEB/RPM formats instead

Type Checking

# Run type checker once
pnpm run check

# Run in watch mode (during development)
pnpm run check:watch

Testing

# Run Rust tests
cd src-tauri && cargo test --all-features

# Run with output
cargo test -- --nocapture

# Run specific test
cargo test test_name

# Run integration tests that require external binaries
TURBOMCP_DEMO_PATH=/path/to/binary cargo test --ignored

# Lint and format
cargo clippy --all-targets --all-features -- -D warnings
cargo fmt --check

Note: Some integration tests are #[ignore]d by default because they require external MCP server binaries. Set the TURBOMCP_DEMO_PATH environment variable to run them locally.

Development

Project Structure

turbomcpstudio/
├── src/                            # SvelteKit frontend
│   ├── routes/                     #   Page routes (+layout.svelte, +page.svelte)
│   └── lib/
│       ├── components/             #   Svelte 5 components (runes mode)
│       │   ├── layout/             #     Shell: Sidebar, MasterLayout, StatusBar
│       │   ├── ui/                 #     Reusable: Button, JsonViewer, FormField, etc.
│       │   └── sampling/           #     Sampling approval UI
│       ├── stores/                 #   Svelte stores (server, profile, sampling, OAuth, etc.)
│       ├── types/                  #   TypeScript type definitions
│       ├── utils/                  #   Helpers: logger, schema validation, cost estimation
│       └── constants/              #   App-wide constants and timeouts
├── src-tauri/                      # Rust backend (Tauri 2.0)
│   ├── src/
│   │   ├── commands/               #   Tauri IPC command handlers
│   │   ├── mcp_client/             #   MCP client: transport, health, sampling, rate limiting
│   │   ├── oauth/                  #   OAuth 2.1: flows, tokens, callback server, DPoP
│   │   ├── proxy/                  #   MCP proxy, benchmarking, metrics
│   │   ├── types/                  #   Shared Rust type definitions
│   │   ├── database.rs             #   SQLite via sqlx (migrations, queries)
│   │   ├── hitl_sampling.rs        #   Human-in-the-loop sampling manager
│   │   ├── workflow_engine.rs      #   Multi-step workflow execution
│   │   ├── error.rs                #   Structured error types
│   │   └── lib.rs                  #   App setup, state, plugin registration
│   ├── tests/