Overview

MCP Linker is a lightweight utility that lets you run and manage a local MCP (Model Context Protocol) server through a cross-platform Tauri GUI. It provides one-click adapters and configuration helpers so desktop and editor clients—such as Claude Desktop, Cursor, Windsurf, Visual Studio Code, Cline and Neovim—can connect to local or remote model runtimes via a single MCP endpoint.

For developers working with multiple tools and integrations, MCP Linker simplifies the common tasks of starting a local MCP server, mapping model names, enabling TLS/API key protection, and configuring client-specific connection settings. It is intended to reduce boilerplate and make it straightforward to share a model endpoint across apps on the same machine or within a team.

Features

Cross-platform Tauri GUI for one-click setup and runtime control
Pre-built adapters and quick-config presets for Claude Desktop, Cursor, Windsurf, VS Code, Cline, and Neovim
Local and remote model routing (map local model IDs to client-facing names)
Simple API key and TLS configuration for protected deployments
Start/stop server controls and runtime logs from the GUI
Export/import configuration profiles for reproducible setups
CLI mode for headless / automated deployments

Installation / Configuration

Prerequisites

Node.js (16+) and a package manager (npm, yarn or pnpm) if building from source
Rust and Cargo for Tauri builds (if building native bundles)
Optional: mkcert or LetsEncrypt if you want TLS locally

Download prebuilt releases (recommended)

Visit the GitHub releases page and download the installer or archive for your platform: https://github.com/milisp/mcp-linker/releases
Install/run the downloaded binary or app package and follow the GUI prompts.

Build from source

# Clone repository
git clone https://github.com/milisp/mcp-linker.git
cd mcp-linker

# Install JS dependencies (example using npm)
npm install

# Run in dev mode
npm run tauri dev

# Build native bundles (requires Rust)
npm run build
# Output: platform installers / binaries in src-tauri/target or dist folder

Basic configuration (example)

Default MCP endpoint: http://localhost:3366
Set an API key to protect your local server:
- In the GUI: Server > Security > Enable API key and paste a value
- Or set environment variables when running headless:

export MCP_LINKER_PORT=3366
export MCP_LINKER_API_KEY="your-api-key"
./mcp-linker --headless

Example server JSON config

{
  "port": 3366,
  "tls": {
    "enabled": false,
    "cert": "",
    "key": ""
  },
  "apiKey": "changeme",
  "modelMappings": {
    "claude-v1": "local-llama-2",
    "gpt-like": "remote-provider/gpt"
  }
}

Available Resources

GitHub repository and releases: https://github.com/milisp/mcp-linker
Quick-connect presets (available from the GUI):
- Claude Desktop — one-click set MCP URL
- Cursor — custom runtime endpoint setup
- Windsurf — integration helper for local endpoints
- Visual Studio Code — settings/extension snippets
- Cline — CLI integration hints
- Neovim — sample init.vim/Lua snippet

Configuration table (how clients typically connect)

Client	Typical setting	Example
Claude Desktop	Custom MCP/Proxy URL	http://localhost:3366
Cursor	Runtime / Model endpoint	http://localhost:3366/models/claude-v1
Windsurf	Provider URL	http://localhost:3366
VS Code	settings.json entry	“mcpLinker.endpoint”: “http://localhost:3366”
Cline	CLI flag or env var	CLINE_MCP_URL=http://localhost:3366
Neovim	plugin/global var	let g:mcp_linker_url = “http://localhost:3366”

Use Cases

Local desktop multimodal testing
- Start MCP Linker GUI, enable a local model runtime (or point to a remote model), and click the Claude Desktop preset. Claude Desktop will use the MCP endpoint to interact with the configured model without changing its internal model selection.
Unified model endpoint for editors
- Run MCP Linker on your workstation and map friendly model names to different backends (local LLMs vs. cloud). Configure VS Code and Neovim to use http://localhost:3366 so both editors share the same model mappings and API key, producing consistent responses in editor-based chat and code actions.
Protected team access on a server
- Deploy MCP Linker headless on a remote machine behind TLS and require an API key. Share the HTTPS endpoint and key with a small team so they can connect editors or clients securely to the same model endpoint.
CI / Testing automation
- Use the CLI/headless mode to spin up a temporary MCP server in CI, point tests to the MCP endpoint, and tear it down after tests complete. Use exported config profiles to guarantee reproducible test environments.

Tips and Troubleshooting

If a client

MCP Linker: One-Click MCP Server Setup and Management