Automation & Ops mcp-gatewaymcp-registryself-hostingaccess-controltool-discoveryopentelemetrydockerpostgresql

MCPJungle

Manage and connect multiple MCP servers through one self-hosted endpoint.

FollowAgents review · FARS-2.1
Use with care
65/ 100 5-point scale 3.3 / 5
1 2 3 4 5 6
1Trust13 / 29 · 2.2/5

Tool groups, global disable controls, and the container's lack of host-filesystem access by default provide reasonable least-privilege measures, but every tool and prompt from a newly registered server is enabled by default. No user-confirmation mechanism is shown before tools with external effects are invoked, so that criterion receives zero. The README explains the flow among clients, gateway, upstream MCP servers, databases, and environment variables fairly clearly, but does not fully describe telemetry fields, log contents, or retention. Environment placeholders, bearer-token fields, and password files provide basic secret handling; encryption at rest, redaction, rotation, and protected token storage are not documented. go.mod pins dependency versions, but there is no evidence of vulnerability scanning, dependency review, update policy, or supply-chain controls. Registration, invocation, and STDIO execution can cause network, process, and downstream-tool effects without documented confirmation or effect previews. Disable, deregistration, and persistence warnings offer limited recovery, but tool-call rollback and backup restoration are absent. Canonical server-qualified tool names preserve useful upstream attribution and the module path is clear, although publisher identity is unverified and no fuller maintainer attribution is supplied.

2Reliability8 / 14 · 2.9/5

The material documents a health check, graceful shutdown, stateful-connection lifecycle, failure on missing environment variables, and troubleshooting through stderr and server logs. The main deduction is a material inconsistency between the server's documented default port 8080 and the CLI's documented default registry address on port 8000, compounded by current guidance coexisting with a legacy reference. Binaries, Homebrew, containers, and host execution provide several availability paths, and the limits of the STDIO image are stated; offline operation and dependency-failure recovery are not covered. Failure guidance is concrete in several places but lacks a systematic error catalog, structured error contract, or comprehensive remediation guidance.

3Adaptability16 / 18 · 4.4/5

The documentation thoroughly distinguishes personal local use, shared team infrastructure, development mode, and enterprise mode, and covers Claude, Cursor, Copilot, and custom agents. Capability boundaries are unusually explicit: supported transports, immature SSE, container filesystem isolation, included STDIO runtimes, session behavior, and database options are all described. Canonical double-underscore names, tool groups, and enable/disable controls improve trigger precision, but default enablement and the absence of conflict resolution, hazardous-tool classification, or per-call policy prevent full marks. Docker, host, macOS, Kubernetes, SQLite, PostgreSQL, and remote deployments receive concrete environment-specific guidance.

4Convention12 / 18 · 3.3/5

The README has a quickstart, table of contents, scenario-based sections, and command examples, but much of the detail is labeled legacy while the latest operational material is moved to an external documentation site not included in evidence. Installation, verification, startup, connection, and platform notes are thorough. Product capitalization varies, production was renamed enterprise, and the 8080/8000 address mismatch weakens naming and configuration stability. Examples are extensive and show an end-to-end call, but there is no real FAQ or comprehensive troubleshooting matrix. Several limitations are explicit, including immature SSE, macOS notarization, container filesystem access, extra STDIO dependencies, and cold-start tradeoffs, though no complete centralized limitation inventory is provided. The full MPL-2.0 license is present and matches metadata. A Releases reference and one rename note exist, but no changelog or versioning policy is supplied. Documentation, roadmap, Discord, and contributing references imply update channels, yet no accountable maintainer, response commitment, or security-update path is identified; the unknown publisher identity is not otherwise penalized.

5Effectiveness12 / 13 · 4.6/5

The unified endpoint, canonical tool names, discovery, prompt support, tool groups, and client-specific configurations produce directly usable outcomes, with a complete registration-to-invocation example. Central registration, access control, and observability offer clear marginal value over duplicating multiple server configurations in every client. The documentation acknowledges cold-start latency, persistent-session resource use, larger STDIO images, and production database choices, but provides no capacity measurements, performance evidence, operating-cost estimates, migration cost, or quantified security tradeoffs, so cost-benefit treatment is adequate rather than thorough.

6Verifiability4 / 8 · 2.5/5

Many operational claims map to concrete commands, configuration schemas, endpoints, and pinned go.mod versions, giving moderate traceability. However, no implementation code, tests, or deployment configuration is supplied to statically verify central claims about access control, session management, or observability. The license agrees with metadata and the module path agrees with repository identity, but most functional claims are corroborated only by the README. Defaults, recommendations, limitations, and examples are generally distinguished, including an explicit maturity warning for SSE; broader claims about centralization, security, and production suitability are not accompanied by enough evidence for complete fact-versus-inference separation.

Evidence confidence: Low Reviewed Aug 14, 2026 Reviewed revision 12648be5edc7
Safety controls not found in source: confirmation before acting
Before you use it
  • All tools and prompts from a newly registered server are enabled by default; shared deployments should narrow exposure with tool groups or explicit disabling.
  • The supplied material shows no user confirmation, effect preview, or per-call rollback mechanism for high-impact tool invocations.
  • The README gives port 8080 as the server default but port 8000 as the CLI's default registry address; verify the actual deployment configuration.
  • Storage, redaction, retention, and encryption policies for tokens, request data, telemetry, and logs are not documented in the supplied files.
  • Dependencies are version-pinned, but no vulnerability scanning, supply-chain verification, or security-update process is evidenced.
  • STDIO servers can launch configured commands, and filesystem reach depends on mounted paths; register only trusted servers and use narrowly scoped mounts.
  • This assessment is limited to the supplied README, LICENSE, and go.mod; the software was not executed, and external documentation or release artifacts were not verified.
Review evidence [1][2][3]
See the full review method →

What does this agent do, and when should you use it?

MCPJungle is a self-hosted MCP gateway and registry for individual developers and teams. It combines a server with a CLI: the server registers upstream MCP servers and exposes a unified Streamable HTTP endpoint at `/mcp`, while the CLI manages servers, tools, prompts, and invocations. Upstreams can use Streamable HTTP or stdio; SSE support exists but is described as immature, and tools are presented under canonical `<server-name>__<tool-name>` names. Stateless operation opens and closes an upstream connection for each call, while optional stateful sessions reuse connections to reduce cold-start latency. A local SQLite setup can grow into shared infrastructure backed by PostgreSQL, Docker Compose, access controls, tool groups, and OpenTelemetry metrics.

An operator registers a remote Streamable HTTP server or a local stdio command with mcpjungle register or a JSON configuration containing its URL, command, arguments, environment, bearer token, and headers. MCPJungle reads the upstream tools and prompts, assigns canonical <mcp-server-name>__<tool-name> identifiers, and exposes them through commands such as mcpjungle list tools, mcpjungle usage, and mcpjungle invoke. An AI client connects to the unified /mcp endpoint; the gateway routes each call to the appropriate upstream server and returns its result. Operators can disable servers, tools, or prompts globally and create Tool Groups with separate MCP endpoints that expose selected servers or tools. Enterprise mode adds server initialization, user and MCP Client tokens, per-client server allowances, and OpenTelemetry metrics enabled by default.

  1. A developer using several MCP servers from Claude Desktop, Cursor, or Codex wants one local client configuration instead of wiring every server into every application.
  2. A platform team wants a shared registry where staff can discover and call centrally managed MCP tools.
  3. A security-conscious team needs separate client tokens and explicit control over which upstream servers each MCP client may access.
  4. A team with hundreds of registered tools wants Tool Groups that expose only the subset relevant to a particular client.
  5. An operations team wants to deploy the gateway with Docker and PostgreSQL and scrape Prometheus-compatible metrics from /metrics.
  6. A developer using slow-starting stdio servers wants stateful sessions that reuse connections and avoid repeated process startup.

What are this agent's strengths and limitations?

Pros
  • Consolidates multiple upstream MCP servers behind one Streamable HTTP endpoint, reducing repeated client configuration.
  • Supports both Streamable HTTP and stdio upstreams, with stateless and stateful connection modes for different cleanup and latency needs.
  • Tool Groups create dedicated endpoints with inclusion and exclusion rules for tools and whole servers.
  • Enterprise mode provides MCP Client tokens, server-level permissions, user accounts, and OpenTelemetry metrics.
  • Runs lightly with local SQLite while also supporting Docker and PostgreSQL for shared deployments.
Limitations
  • OAuth flows are not supported; upstream authentication is currently limited to static bearer tokens or custom headers.
  • SSE support is explicitly described as immature, making SSE-dependent adoption riskier.
  • Tool Groups do not include prompts and cannot be updated in place; they must be deleted and recreated.
  • The gateway environment must contain every runtime needed by stdio servers, while the standard image excludes npx and uvx.
  • Filesystem MCP servers inside Docker require explicit host-volume mounts and container-path configuration.
  • Centralizing calls adds an infrastructure dependency whose database, credentials, networking, and availability must be operated.

How do you install or deploy this agent?

The documented local quickstart requires Docker and Docker Compose:

curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.yaml
docker compose up -d

This exposes the MCP endpoint at http://localhost:8080/mcp by default. Install the CLI with Homebrew:

brew install mcpjungle/mcpjungle/mcpjungle
mcpjungle version

A standalone binary is also available from GitHub Releases, and the container can be pulled with:

docker pull ghcr.io/mcpjungle/mcpjungle

Running mcpjungle start directly creates mcpjungle.db in the current directory unless another database is configured. Shared deployments can supply a PostgreSQL DSN through DATABASE_URL. Use the latest-stdio image for stdio servers that depend on npx or uvx; other command dependencies require a custom image.

How do you use this agent?

Register a working upstream MCP server and inspect its tools:

mcpjungle register --name context7 --url https://mcp.context7.com/mcp
mcpjungle list tools

Then configure Claude Desktop to use the unified endpoint. This documented connection requires npx and mcp-remote:

{
"mcpServers": {
"mcpjungle": {
"command": "npx",
"args": ["mcp-remote", "http://localhost:8080/mcp", "--allow-http"]
}
}
}

A first test is to ask Claude to use Context7 for the /lodash/lodash documentation. Tools can also be exercised directly, for example:

mcpjungle invoke calculator__multiply --input '{"a": 100, "b": 50}'

For a remote registry, use mcpjungle --registry http://my-server:9000 list tools. In enterprise mode, run mcpjungle init-server, create a client with mcpjungle create mcp-client <name> --allow "server1,server2", and send its generated token as Authorization: Bearer <token>.

How does this agent compare with similar options?

Compared with configuring every MCP server separately in every AI client, MCPJungle centralizes registration, discovery, access control, and invocation behind one gateway. Direct connections avoid operating that extra layer, but retain duplicated and scattered configuration.

FAQ

Is PostgreSQL required for local use?
No. A direct start defaults to a SQLite file named mcpjungle.db in the current directory. PostgreSQL is supported for more serious or shared deployments; deleting the SQLite file removes the registered-server data and other stored state.
Can it connect to an MCP service that requires OAuth?
Not through an OAuth flow yet. Streamable HTTP upstreams can instead receive a static bearer token, a custom Authorization value, or other configured HTTP headers.
How do development and enterprise permissions differ?
In development mode, MCP clients can access every registered server. In enterprise mode, a client initially has no server access; an administrator must create an MCP Client and explicitly allow specific servers.
How can stdio cold-start latency be reduced?
The default stateless mode opens a new connection for each call. Setting session_mode to stateful reuses the connection after its first invocation, with optional global idle expiry through SESSION_IDLE_TIMEOUT_SEC.
Can a Tool Group expose a globally disabled tool?
No. A globally disabled or deleted tool is unavailable through every group. If it is later re-enabled or added again, it automatically becomes available in groups that include it.

Related agents