---
title: "MCP Setup on Mac: Connect Claude Code, Cursor, Windsurf, and More"
description: "Set up MCP with Claude Code, Cursor, Claude Desktop, Windsurf, VS Code, Zed, or Aider on macOS. One server, over 300 tools, every editor."
date: 2026-05-08
author: "Ben Racicot"
tags: ["MCP", "Model Context Protocol", "Claude Code", "Cursor", "Windsurf", "Privacy", "macOS", "Developer Tools"]
type: "article"
canonical: "https://modelpiper.com/blog/mcp-setup-guide-mac/"
---

# MCP Setup on Mac: Connect Claude Code, Cursor, Windsurf, and More

> Set up MCP with Claude Code, Cursor, Claude Desktop, Windsurf, VS Code, Zed, or Aider on macOS. One server, over 300 tools, every editor.

## TL;DR

MCP (Model Context Protocol) is how AI editors discover and call tools. Point your editor at a running ToolPiper instance at http://127.0.0.1:9998/mcp and over 300 local tools show up the next time you start a chat. Claude Code, Cursor, Claude Desktop, Windsurf, VS Code, Zed, and Aider all support MCP. Each editor has a slightly different registration syntax. The wire format is identical.

MCP is the reason your AI editor can do anything beyond chat. Without it, an editor knows how to read files and run a model. With it, an editor can call any function exposed by a connected server. ToolPiper is one of those servers, and it runs on your Mac.

Hooking ToolPiper into an MCP-capable editor takes one line of configuration. The rest of this guide covers what that line looks like for the seven editors we test against, what shows up in your editor after the registration, and the gotchas that fail silently when something's off.

## What is MCP and why does my AI editor care?

MCP (Model Context Protocol) is an open standard from Anthropic for connecting AI assistants to external tools. A server exposes tools as JSON-RPC functions. A client like Claude Code discovers them on startup. The model decides when to call them during a conversation.

Before MCP, every assistant had its own plugin format. ChatGPT plugins. Claude tool use. Cursor commands. Each was incompatible with the others. **MCP standardizes the integration surface so tools written once work in every MCP-capable editor.**

The protocol is wire-level simple. The editor sends a JSON-RPC `tools/list` request when it connects, the server returns the catalog (tool name, description, parameter schema). When the model decides to call a tool, the editor sends `tools/call` with the chosen tool and arguments. The server runs the tool and returns the result. That's the whole loop.

For ToolPiper, the loop runs on your Mac. Both the editor and the server live on the same machine, talking over loopback. There's no relay, no cloud component, no extra hop. [Local MCP Server on Mac: 300+ AI Tools in One Install](/blog/mcp-server-local-mac) goes deeper on what each of those over 300 tools is.

## How does ToolPiper appear in my editor?

As a tool source labelled "toolpiper" with over 300 tools grouped by category. The editor shows them in its tool picker. The model invokes them as needed during a chat.

The 300+ tools break down roughly into eleven groups:

-   **Local inference (12).** `chat`, `text_translate`, `text_embed`, `text_analyze`, `image_analyze`, `audio_transcribe`, `audio_speak`, `vision_ocr`, and model lifecycle controls.
-   **Browser automation (15).** CDP-based, accessibility-tree primary, with assertions, network capture, performance, recording.
-   **System control (154).** Windows, hotkeys, audio, displays, dock, Finder, focus, network, processes, notifications, calendar, contacts, reminders, accessibility, storage, and more.
-   **Web (3).** `web_scrape` for AX-tree extraction, `web_search`, `web_api_discover`.
-   **Audio (5).** Recording, transcription, speech synthesis, voice cloning.
-   **Vision (5).** Screenshots, OCR, color picking, camera capture, screen streaming.
-   **Video (24).** AI-driven video creation from screenplay to render, plus PiperSR upscaling.
-   **Testing (9).** PiperTest AX-native test format with self-healing selectors.
-   **RAG (3).** `rag_ingest`, `rag_query`, `rag_collection_list` for local knowledge bases.
-   **OAuth (4).** Connect, disconnect, status, plus Search Console tools.
-   **Files, git, and shell.** Read, write, list, create, delete, plus full git operations.

The editor's model decides which tool to invoke based on the conversation. You ask "what's on my screen", the model picks `vision_screenshot`. You ask "summarize this audio file", it picks `audio_transcribe` then routes the transcript through `chat`. The model handles the orchestration. You write natural-language prompts.

## Which editors support MCP?

Claude Code, Cursor, Claude Desktop, Windsurf, VS Code (with Cline or Continue), Zed, and Aider all support MCP. The wire format is identical across them, but each has its own registration mechanism.

Each editor in the list has a dedicated setup guide on this site. Click through for the install steps, the verification commands, and the editor-specific troubleshooting.

-   [**Claude Code**](/blog/claude-code-mcp-setup-toolpiper). CLI registration, supports HTTP transport directly.
-   [**Cursor**](/blog/cursor-mcp-setup-toolpiper). JSON config at `~/.cursor/mcp.json` or per-project.
-   [**Claude Desktop**](/blog/claude-desktop-mcp-setup-mac). JSON config in Application Support, requires full app relaunch.
-   [**Windsurf**](/blog/windsurf-mcp-setup-toolpiper). JSON config at `~/.codeium/windsurf/mcp_config.json`.
-   [**VS Code** with Cline or Continue](/blog/vscode-cline-continue-mcp-toolpiper). Depends on the extension.
-   [**Zed**](/blog/zed-editor-mcp-setup). JSON config in editor settings.
-   [**Aider**](/blog/aider-mcp-setup). CLI flag or config file.

Some editors (Cursor especially) ship their own MCP marketplace with one-click installs for cloud-hosted servers. ToolPiper is a local server, so it doesn't appear in those marketplaces. The JSON config path is the route in.

## What does an MCP setup actually look like?

Every editor needs three things from you: the server URL or stdio command, a name for the server, and a restart to pick up the change. ToolPiper exposes HTTP at `http://127.0.0.1:9998/mcp`. Pass that URL plus a server name ("toolpiper") through whatever registration mechanism your editor uses.

The pattern's the same regardless of editor:

1.  Add ToolPiper as an MCP server. CLI command or JSON snippet pointing at `http://127.0.0.1:9998/mcp`.
2.  Restart the editor. A window close usually isn't enough. The editor reads MCP config on startup, not on file change.
3.  Verify tools are visible. Open a new chat and look at the tool indicator. If you see over 300 toolpiper tools, you're done.

Two transports are supported. **HTTP** at `http://127.0.0.1:9998/mcp` is the modern path. One URL, no process management, no PATH variables. **stdio** is the older transport, where the editor spawns a process and pipes JSON-RPC through stdin/stdout. ToolPiper supports both, but the HTTP transport is simpler for most editors. Use stdio only if your editor doesn't support HTTP MCP yet. Some older Claude Desktop builds fall in that category.

## Why does ToolPiper need to be running?

Because the MCP server lives inside the ToolPiper app, not as a standalone daemon. If you quit ToolPiper, the HTTP endpoint goes with it. Editors discover tools at startup and re-poll periodically. A discovery against a dead server returns zero tools.

This is the failure mode that catches most setups. The editor logs "MCP server failed to connect" and the user assumes the URL is wrong. Nine times out of ten, ToolPiper just isn't open.

Quick sanity check before you debug anything else. Run `curl http://127.0.0.1:9998/health`. A response means ToolPiper is alive. Connection refused means it isn't. Launch the app, then restart your editor.

ToolPiper lives in the menu bar by default, so the icon's presence is a faster visual check than running curl. If you want ToolPiper to launch at login, the setting's in Preferences. We don't enable it by default because some users prefer to start ToolPiper on demand.

## What if my editor doesn't have a guide here?

Follow the same pattern. Find your editor's MCP config (CLI command, JSON file, or settings UI), add a server named "toolpiper" pointing at `http://127.0.0.1:9998/mcp`, restart. The wire format is standard MCP, so any compliant client works.

If you hit a problem and want it documented, file an issue with the editor name, the config you tried, and the error message. We'll add the guide.

## FAQ

### Is the MCP server authenticated?

The HTTP MCP endpoint at `http://127.0.0.1:9998/mcp` is loopback-only, so requests from outside your Mac never reach it. There's no token to paste into your editor. If you enable LAN access in ToolPiper preferences (for connecting from another device on your network), the endpoint switches to token-based authentication with `tp_lan` tokens.

### Does ToolPiper support stdio or HTTP MCP transports?

Both. HTTP is the recommended transport for editors that support it. stdio is the fallback for editors that don't speak HTTP MCP yet. The same over 300 tools are available on either transport.

### Can I use ToolPiper alongside other MCP servers?

Yes. MCP is designed for multiple servers per editor. Most editors let you register as many MCP servers as you want, and the model sees the combined tool catalog. Run ToolPiper alongside Playwright MCP, filesystem MCP, GitHub MCP, anything else. The editor handles the routing.

### What if my editor has its own MCP marketplace?

Marketplaces (like Cursor's) list cloud-hosted MCP servers that the marketplace operator vetted. ToolPiper is a local server, so it doesn't appear there. The marketplace install path doesn't apply. Use the editor's manual JSON config path instead. Every editor with a marketplace also supports manual registration.

### Does an MCP tool call leave my Mac?

The MCP call itself never leaves loopback. Whether the tool's work stays local depends on what the tool does. `chat` against a local model is fully local. `web_scrape` reaches the URL you asked it to scrape. `gsc_analytics` hits Google's API with your OAuth token. The tool's documentation tells you whether it needs network access.
