Mcpproxy Go

Mcpproxy Go

Free, MIT-licensed local MCP proxy that gives every AI client one shared MCP endpoint, with BM25 tool discovery, profiles and quarantine.

70/100Safe BetFreeFree

If you run a pile of MCP servers and your client is choking on tool definitions, MCPProxy is the most sensible free fix we've seen. BM25 discovery means the agent pulls only the schemas it needs, and v0.70.0's profiles with per-tool policy plus per-client credentials turn "every agent gets everything" into a boundary you actually set. The quarantine-then-review flow is a genuine control, not a marketing bullet. The docs are refreshingly direct — they state plainly that local-first does not make the whole workflow offline, and that a clean scan is not proof of safety. It is desktop software you configure yourself, so it suits developers and small teams rather than buyers who want a managed

Verified 5d ago · liveness 70/100 · cite: rightaichoice.com/tools/mcpproxy-go

Best for
  • Developers juggling many MCP servers across multiple AI clients
  • Cursor, Claude Code and Codex users hitting client-side tool limits
  • Security-minded teams wanting quarantine and approval before tool execution
  • Solo devs and small teams who want a free, self-hosted MCP proxy
Not ideal for
  • Non-technical users who want a point-and-click setup
  • Teams needing cross-machine hosted access with role-based permissions
  • Anyone who wants a vendor-managed cloud proxy and zero install
Visit Website

IntermediateMost developers reach first value in 10-20 minutes: install via Homebrew, DMG or a signed apt/dnf repository, run mcpproxy serve, add a couple of MCP servers, then connect one client using the per-client connection guide. Budget longer if you want Docker isolation and per-client credentials — those are deliberate configuration steps, not defaults.Desktop · CLI · WebAPI availableVerified 5d ago
Pricing
Free
FreeFree tier
Learning curve
Intermediate
Most developers reach first value in 10-20 minutes: install via Homebrew, DMG or a signed apt/dnf repository, run mcpproxy serve, add a couple of MCP servers, then connect one client using the per-client connection guide. Budget longer if you want Docker isolation and per-client credentials — those are deliberate configuration steps, not defaults.
Runs on
DesktopCLIWeb
API available · 16 integrations
Who it's for
Developer using Cursor, Claude Code and Codex against the same server setSecurity-minded engineer onboarding a third-party MCP serverSmall team scoping what each internal agent can reach
Live sentiment
Is Mcpproxy Go actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip MCPProxy if you need a vendor-managed, cross-machine hosted proxy with role-based permissions and zero local install, rather than a local Go application you configure yourself on your own machine.

The 30-second take
Price reality

MCPProxy is MIT-licensed and free, which puts it below paid MCP gateways and hosted agent-tooling platforms that charge per seat or per routed call. The trade is that you supply the machine, the Docker runtime if you want isolation, and the review time — quarantine, profiles and credential scoping all assume a human deciding what gets approved.

In short

Mcpproxy Go — Free, MIT-licensed local MCP proxy that gives every AI client one shared MCP endpoint, with BM25 tool discovery, profiles and quarantine. Best for Developers juggling many MCP servers across multiple AI clients, Cursor, Claude Code and Codex users hitting client-side tool limits, Security-minded teams wanting quarantine and approval before tool execution. Free to use.

What's new in Mcpproxy Go

Checked 7 days ago

Across the latest 1 update: 1 changelog entry.

What people actually say about Mcpproxy Go — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

5 mentions across 2 sources (Hacker News, GitHub) · researched Jul 3, 2026.

77% positive23% critical

Average across the 2 sources that answered — each source counts once, not each post.

Recurring strengths
  • +Bypasses Cursor's 40-tool and OpenAI's 128-function API limits easily.
  • +BM25 semantic matching reduces token usage by up to 99%.
  • +Security features: automatic quarantine and TPA detection protect users.
  • +Works fully offline with no cloud dependency.
  • +One-click install into Cursor IDE via deeplink.
Recurring frustrations
  • −Early-stage product – few real-world reviews or long-term reliability data.
  • −Documentation on advanced configuration and troubleshooting is sparse.
  • −Some users report crashes when adding many MCP servers.
  • −Requires some comfort with JSON config files and CLI.
  • −No web UI – all interaction via desktop app and config file.
Patterns worth knowing
Tool discovery via BM25 routing solves token bloat and context limits
Seen on Hacker News
Bypassing vendor-imposed tool caps (Cursor 40, OpenAI 128) is a key need
Seen on Hacker News
Security features (quarantine, TPA detection) are valued but unproven at scale
Seen on Hacker News
Learning curve
intermediateProductive in ~A few hours
Hidden costs people mention
  • • No hidden costs – entirely free and open-source.

Viability Score

70/100
Safe Bet

How well maintained and how widely used is Mcpproxy Go? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
72
Site health
95
User sentiment
77
What the vendor publishes
40

Last calculated: October 2026

How we score →

Key Features

  • Single shared MCP endpoint for multiple AI clients
  • BM25 natural-language tool discovery across connected servers
  • On-demand tool schema fetching in retrieve_tools and code_execution routing modes
  • Direct routing mode that lists upstream tools individually
  • Automatic quarantine for newly added MCP servers and tools
  • Tool Poisoning Attack (TPA) pattern detection on tool definitions
  • Tool definition-change review under manual trust mode
  • Sensitive-data detection for API keys and credentials in tool arguments and responses
  • Optional output sanitisation to redact secrets or block critical detections in supported text responses
  • Schema checks on tool definitions
  • Offline-capable built-in tool scanner
  • Profiles grouping servers into explicit scopes with per-tool policy (v0.70.0)
  • Scoped, revocable per-client credentials pinned to a profile (v0.70.0)
  • Agent server discovery (v0.70.0)
  • Single needs-attention list for flagged servers and tools (v0.70.0)

About Mcpproxy Go

FreeIntermediateAPI availableDesktop · CLI · Web

MCPProxy is a free, MIT-licensed Go application that runs on your machine and sits between your AI clients and your MCP servers. You add your servers once in MCPProxy, then point Cursor, Claude Code, Codex, OpenCode, Claude Desktop, VS Code Copilot, Goose or Windsurf at a single shared MCP endpoint instead of wiring each integration by hand. It is built for developers running enough MCP servers that setup sprawl and context bloat become real problems. The discovery layer is BM25 natural-language search indexed across all connected servers. In the default retrieve_tools and code_execution routing modes your agent loads a small set of MCPProxy discovery and execution tools and fetches tool schemas on demand rather than loading the full upstream catalog — the docs are explicit that direct routing lists upstream tools individually and does not reduce initial context, and that savings depend on tool count, routing mode and the task. Around that sit profiles and scoped, revocable credentials. Version 0.70.0 (October 2026) added profiles with per-tool policy, per-client credentials for each connected client, a single needs-attention list, and agent server discovery. Tool security combines automatic quarantine for newly added servers, Tool Poisoning Attack pattern detection, definition-change review, sensitive-data detection with optional output sanitisation, and schema checks. Secrets live in the OS keyring, Docker isolation is optional for local stdio servers with Python/Node.js runtime detection, and you drive the proxy through an embedded Web UI, a CLI, or a tray menu on macOS, Windows and Linux.

Behind the Verdict

MCPProxy solves a problem that arrives quietly. You add a filesystem server, then GitHub, then Playwright, then Jira, then Slack and PostgreSQL, and suddenly every one of your AI clients is loading hundreds of tool definitions before it does any work. MCPProxy puts one endpoint in front of all of them and indexes the tools with BM25, so the agent asks for a capability and gets back only the relevant schemas. Per the docs, that saving only applies in the retrieve_tools and code_execution routing modes; direct routing still lists upstream tools individually. The access model is the part that separates this from a plain connection multiplexer. Profiles group servers into explicit scopes, and scoped credentials let you pin a specific client or agent to a profile, so your research agent doesn't inherit your production database tools. v0.70.0 pushed further with per-tool policy inside profiles, per-client credentials, a single needs-attention list and agent server discovery — a meaningful step up from the seed data's description of profiles plus tokens alone. On security, MCPProxy is honest in a way that matters. New servers are quarantined until approved. Tool Poisoning Attack patterns are scanned for, tool definition changes are held for review under the default manual trust mode, sensitive data in arguments and responses is flagged, and schema checks run against definitions. The docs also spell out the exceptions rather than hiding them: input-schema-only edits outside scan mode, a newly added output schema, and a description added to a tool approved with an empty description all slip past manual review, and scan or auto modes admit more without a human. If you want automatic safety, this isn't it — and the project says so. Where it fits: developers and small teams on macOS, Windows or Linux who already run MCP servers locally and want to stop duplicating configuration across clients. The CLI checks required tools and orchestrates calls in JavaScript or TypeScript, which makes it usable in repeatable workflows rather than just interactive use. Where it doesn't: anyone who wants a point-and-click setup, teams needing cross-machine hosted access with role-based permissions, or buyers who want a vendor-managed cloud proxy. The core server binds to 127.0.0.1:8080 by default, LAN access is optional, and the proxy has no AI model of its own — it depends on upstream servers being reachable.

Researching Mcpproxy Go? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Mcpproxy Go actually fits — and what changes day-one when you adopt it.

Developer using Cursor, Claude Code and Codex against the same server set

You install MCPProxy, add your filesystem, GitHub, Playwright, Context7, Jira, Slack and PostgreSQL servers once, then point all three clients at the shared endpoint and confirm routed calls appear in the Web UI.

Outcome: One server configuration instead of three, and a single activity view showing which client made which call and what it returned.

Security-minded engineer onboarding a third-party MCP server

You add the new server, watch it land in quarantine, then use the TPA scanner and definition review (or ask your agent to review the findings) before approving it — and you note that approval is still yours, not the agent's.

Outcome: The server's tools stay unreachable by agents until you sign off, and any later definition change comes back for review under manual trust mode.

Small team scoping what each internal agent can reach

You build a research profile and an ops profile, apply per-tool policy, and issue a scoped credential per connected client so the research agent is pinned to the research profile.

Outcome: Each agent has a defined boundary with a revocable credential, and the needs-attention list surfaces anything flagged without you hunting through server logs.

Use Cases

Limitations

  • MCPProxy is a local-first, MIT-licensed Go proxy that sits between AI clients (Claude Code, Codex, OpenCode, Cursor) and MCP servers — it has no AI model of its own.
  • Security depends on human review: under the default manual trust mode most later changes to an approved tool's definition are held for review, with known exceptions (input-schema-only edits outside scan mode, a newly added output schema, and a description added to a tool approved with an empty description), and scan/auto modes admit more; quarantine reduces but does not guarantee protection against Tool Poisoning Attacks.
  • Tool-discovery savings depend on tool count, routing mode and task — direct routing lists upstream tools individually and does not reduce initial context.
  • Sensitive-data output sanitisation does not apply in direct routing mode or to upstream error results, and local activity records are for debugging, not a compliance certification.

as of 2026-10-13

Verification history

We have re-verified Mcpproxy Go 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-checked, vendor evidence unchanged
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — re-checked, vendor evidence unchanged

Showing the 6 most recent of 9 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Mcpproxy Go tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Free

$0/mo

Ideal for

Developers and small teams who already run MCP servers locally and want one shared endpoint plus quarantine, profiles and scoped credentials without paying per seat.

What this tier adds

MIT-licensed entry point: no paid tier, no per-seat charge. You supply the machine, the optional Docker runtime, and the human review that quarantine and manual trust mode depend on.

Where the pricing makes sense

The company stage and team size where Mcpproxy Go's pricing actually pencils out — and where peers do it cheaper.

MCPProxy is MIT-licensed and free, which puts it below paid MCP gateways and hosted agent-tooling platforms that charge per seat or per routed call. The trade is that you supply the machine, the Docker runtime if you want isolation, and the review time — quarantine, profiles and credential scoping all assume a human deciding what gets approved.

Setup time & first value

How long it actually takes to get something useful out of Mcpproxy Go — broken out by persona, not the marketing-page minute.

Most developers reach first value in 10-20 minutes: install via Homebrew, DMG or a signed apt/dnf repository, run mcpproxy serve, add a couple of MCP servers, then connect one client using the per-client connection guide. Budget longer if you want Docker isolation and per-client credentials — those are deliberate configuration steps, not defaults.

Switching to or from Mcpproxy Go

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From hand-wiring each client to each MCP server: add all servers in MCPProxy once and repoint every client at the shared endpoint.
  • →From a single-client MCP config file: import the server list, then choose a routing mode — retrieve_tools or code_execution for on-demand discovery, direct to keep listing upstream tools individually.
Migrating out
  • ↗To per-client MCP configuration: export your server list from the Web UI or CLI and rebuild each client's config from it.
  • ↗To a hosted MCP gateway: keep your existing server definitions as the source list, but expect to reconfigure profiles and credentials under the new provider's access model.

Integrations

CursorClaude DesktopClaude CodeVS Code CopilotChatGPTCodexOpenCodeGooseWindsurfGitHubPlaywrightContext7JiraFilesystemSlackPostgreSQL

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Mcpproxy Go”, and we withheld 6: 6 could not be judged, because “Mcpproxy Go” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Mcpproxy Go.

Official links

Featured Head-to-Head Comparisons

Popular in MCP Servers & Agent Tooling

Smithery

Smithery

Smithery is an MCP server marketplace and connection layer that handles OAuth, credentials, and session state for your AI agent.

FreemiumTry
Arcade AI

Arcade AI

Arcade AI is the MCP authorization runtime that enforces per-user permissions and logs every action your AI agents take.

FreemiumTry
Chrome DevTools MCP

Chrome DevTools MCP

Open-source MCP server that gives coding agents live Chrome DevTools for debugging, traces, and browser automation.

FreeTry

Frequently Asked Questions

Used Mcpproxy Go? Help shape our editorial sentiment research.