π³ MCPJungle π³
About
One place to manage & connect to all your MCP servers
Details
- License
- MPL-2.0
Explore
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.prod.yaml
docker compose -f docker-compose.prod.yaml up -d
> [!NOTE]
> The enterprise mode used to be called production mode.
> The mode has now been renamed for clarity. Everything else remains the same.
This will start the MCPJungle server along with a persistent Postgres database container.
You can quickly verify that the server is running:
bashcurl http://localhost:8080/health
If you plan on registering stdio-based MCP servers that rely on npx or uvx, use mcpjungle's stdio tagged docker image instead.
bashMCPJUNGLE_IMAGE_TAG=latest-stdio docker compose up -d
> [!NOTE]
> If you're using docker-compose.yaml, this is already the default image tag.
> You only need to specify the stdio image tag if you're using docker-compose.prod.yaml.
This image is significantly larger. But it is very convenient and recommended for running locally when you rely on stdio-based MCP servers.
For example, if you only want to register remote mcp servers like context7 and deepwiki, you can use the standard (minimal) image.
But if you also want to use stdio-based servers like filesystem, time, github, etc., you should use the stdio-tagged image instead.
> [!NOTE]
> If your stdio servers rely on tools other than npx or uvx, you will have to create a custom docker image that includes those dependencies along with the mcpjungle binary.
Production Deployment
The default MCPJungle Docker image is very lightweight - it only contains a minimal base image and the mcpjungle binary.
It is therefore suitable and recommended for production deployments.
For the database, we recommend you deploy a separate Postgres DB cluster and supply its endpoint to mcpjungle (see Database section below).
You can see the definitions of the standard Docker image and the stdio Docker image.
If you're running MCPJungle in your organisation, we recommend running the Server in the enterprise mode:
bash
mcpjungle start --enterprise
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
π³ MCPJungle π³Command (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
This quickstart guide will show you how to:
1. Start the mcpjungle server locally using docker compose
2. Add an MCP server in mcpjungle
3. Connect your Claude Desktop to mcpjungle to access your MCP tools
For running the MCPJungle server locally, docker compose is the recommended way:
You can also run the server directly on your host machine using the binary:
bashmcpjungle start
This starts the main registry server and MCP gateway, accessible on port 8080 by default.
mcpjungle usage calculator__multiply
mcpjungle register -c ./filesystem.json
The config file format for registering a STDIO-based MCP server is:
{
"name": "<name of your mcp server>",
"transport": "stdio",
"description": "<description>",
"command": "<command to run the mcp server, eg- 'npx', 'uvx'>",
"args": ["arguments", "to", "pass", "to", "the", "command"],
"env": {
"KEY": "value"
}
}
You can also watch a quick video on How to register a STDIO-based MCP server.
> [!TIP]
> If your STDIO server fails or throws errors for some reason, check the mcpjungle server's logs to view its stderr output.
When you use a JSON config file to register a mcp server or create other entities like tol groups, the CLI can resolve environment variable placeholders in string values before sending the request to the server.
- Only placeholders written as ${VAR_NAME} are resolved.
- Placeholders can appear anywhere inside a string value, for example prefix-${VAR_NAME}-suffix.
- Resolution happens in the CLI process, so the environment variable must be available where you run the command.
- If a referenced environment variable is not set, the command fails with an error.
- This applies to string fields across the JSON config, including nested objects and string arrays.
Example MCP server config:
{
"name": "affine-main",
"transport": "streamable_http",
"description": "AFFiNE workspace MCP server",
"url": "https://app.affine.pro/api/workspaces/${AFFINE_WORKSPACE_ID}/mcp",
"bearer_token": "${AFFINE_API_TOKEN}",
"headers": {
"X-Workspace": "${AFFINE_WORKSPACE_ID}"
}
}
Example STDIO config:
{
"name": "my-stdio-server",
"transport": "stdio",
"command": "uvx",
"args": ["my-server", "--workspace", "${WORKSPACE_ID}"],
"env": {
"API_TOKEN": "${API_TOKEN}"
}
}
Caveat β οΈ
When running mcpjungle inside Docker, you need some extra configuration to run the filesystem mcp server.
By default, mcpjungle inside container does not have access to your host filesystem.
So you must:
- mount the host directory you want to access as a volume in the container
- specify the mount path as the directory in the filesystem mcp server command args
The docker-compose.yaml provided by mcpjungle mounts the current working directory as /host in the container.
So you can use the following configuration for the filesystem mcp server:
{
"name": "filesystem",
"transport": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/host"]
}
Then, the mcp has access to /host, ie, the current working directory on your host machine.
See DEVELOPMENT.md for more details.
If your MCPJungle server is running in a remote Docker container or Kubernetes cluster, you can also execute the mcpjungle binary directly inside the container:
docker exec -it <container_name> /mcpjungle
kubectl -n <namespace> exec -it po/<pod_name> -- /mcpjungle
> [!NOTE]
> The standard image does not include a shell. Run /mcpjungle directly via docker exec or kubectl exec.
This is useful for running CLI commands from the same environment where the server is running.
By default, the CLI connects to the mcpjungle server at http://127.0.0.1:8000.
If your server is running on a different host or port (e.g., a remote deployment), you can configure the registry URL in two ways:
Option 1: Use the --registry flag
mcpjungle --registry http://my-server:9000 list tools
Option 2: Set it in the config file
Create or edit ~/.mcpjungle.conf:
registry_url: http://my-server:9000
This avoids having to pass the --registry flag on every command.
MCPJungle currently supports authentication if your Streamable HTTP MCP Server accepts static tokens for auth.
This is useful when using SaaS-provided MCP Servers like HuggingFace, Stripe, etc. which require your API token for authentication.
You can supply your token while registering the MCP server:
```bash
mcpjungle start --enterprise
export SERVER_MODE=enterprise
mcpjungle start
mcpjungle invoke calculator__multiply --input '{"a": 100, "b": 50}'
> [!NOTE]
> A tool in MCPJungle must be referred to by its canonical name which follows the pattern <mcp-server-name>__<tool-name>.
> Server name and tool name are separated by a double underscore __.
>
> eg- If you register a MCP server github which provides a tool called git_commit, you can invoke it in MCPJungle using the name github__git_commit.
>
> Your MCP client must also use this canonical name to call the tool via MCPJungle.
The config file format for registering a Streamable HTTP-based MCP server is:
json{
"name": "<name of your mcp server>",
"transport": "streamable_http",
"description": "<description>",
"url": "<url of the mcp server>",
"bearer_token": "<optional bearer token for authentication>",
"headers": {
"<custom http header>": "<value>"
}
}
You can disable and re-enable a specific tool or all the tools provided by an MCP Server.
If a tool is disabled, it is not available via the MCPJungle Proxy or any of the Tool Groups, so no MCP clients can view or call it.
You can disable and enable Prompts as well.
bash
mcpjungle disable tool context7__get-library-docs
mcpjungle enable tool context7__get-library-docs
As you add more MCP servers to MCPJungle, the number of tools available through the Gateway can grow significantly.
If your MCP client is exposed to hundreds of tools through the gateway MCP, its performance may degrade.
MCPJungle allows you to expose only a subset of all available tools to your MCP clients using Tool Groups.
You can create a new group and only include specific tools that you wish to expose.
Once a group is created, mcpjungle returns a unique endpoint for it.
You can then configure your MCP client to use this group-specific endpoint instead of the main gateway endpoint.
You can create a new tool group by providing a JSON configuration file to the create group command.
You must specify a unique name for the group and define which tools to include using one or more of the following fields:
- included_tools: List specific tool names to include (e.g., ["filesystem__read_file", "time__get_current_time"])
- included_servers: Include ALL tools from specific MCP servers (e.g., ["time", "deepwiki"])
- excluded_tools: Exclude specific tools (useful when including entire servers)
Here is an example of a tool group configuration file (claude-tools-group.json):
{
"name": "claude-tools",
"description": "This group only contains tools for Claude Desktop to use",
"included_tools": [
"filesystem__read_file",
"deepwiki__read_wiki_contents",
"time__get_current_time"
]
}
This group exposes only 3 handpicked tools instead of all available tools.
You can currently perform operations like listing all groups, viewing details of a specific group and deleting a group.
You can list and invoke tools within specific groups using the --group flag:
bash
mcpjungle list tools --group claude-tools
mcpjungle invoke filesystem__read_file --group claude-tools --input '{"path": "README.md"}'
``
These commands provide group-scoped operations, making it easier to work with tools within specific contexts and validate that tools are available in your groups.
> [!NOTE]
> If a tool is included in a group but is later disabled globally or deleted, then it will not be available via the group's MCP endpoint.
>
> But if the tool is re-enabled or added again later, it will automatically become available in the group again.
Limitations π§
1. Currently, you cannot update an existing tool group. You must delete the group and create a new one with the modified configuration file.
2. In enterprise` mode, currently only an admin can create a Tool Group. We're working on allowing standard Users to create their own groups as well.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"\ud83c\udf33 mcpjungle \ud83c\udf33": {
"MCPJungle": {
"command": "docker",
"args": [
"compose",
"up",
"-d"
]
}
}
}
}
McpServers
{
"MCPJungle": {
"command": "docker",
"args": [
"compose",
"up",
"-d"
]
}
}
<h1 align="center">
MCPJungle
</h1>
<p align="center">
<strong>Run all your MCP servers behind one endpoint</strong>
</p>
<p align="center">
<a href="https://docs.mcpjungle.com" style="text-decoration: none;">
</a>
<a href="https://github.com/mcpjungle/mcpjungle/pkgs/container/mcpjungle" style="text-decoration: none;">
</a>
<a href="https://discord.gg/CapV4Z3krk" style="text-decoration: none;">
</a>
</p>
MCPJungle is a self-hosted MCP gateway for developers and teams who want to manage multiple MCP servers without scattered client configurations, duplicated setup, or inconsistent access control.
Use it locally to keep your personal MCP setup clean, or run it as shared infrastructure for a team with centralized discovery, access control, and observability.

Instead of wiring every MCP server into every AI client, register your servers once in MCPJungle and let Claude, Cursor, Codex, or your own Agents connect to a single MCP endpoint.
Why MCPJungle?
MCP is powerful, but managing many MCP servers gets messy fast.
Without a gateway:
- π Every client needs its own MCP server configuration
- π§© Tools, prompts, and resources are scattered across different servers
- π Access control is duplicated or missing
- π₯ Teams have no shared view of available MCP tools
- π οΈ Local setups become hard to reproduce
MCPJungle gives you a single control point:
- π One MCP endpoint for Claude, Cursor, Copilot, and custom agents
- ποΈ One place to register and manage MCP servers
- π Unified discovery for tools, prompts, and resources
- ποΈ Optional tool groups to expose only the tools a client should see
- π Simple access-control and observability hooks for shared deployments
Start with a local setup. Scale to a shared team gateway when you need it.

Documentation
Mcpjungle documentation has a new home: https://docs.mcpjungle.com. Please prefer the docs site over this README for the latest guides, reference, and operational details. Your AI Clients can also access the docs using its MCP serverhttps://docs.mcpjungle.com/mcp!
Quickstart
This quickstart guide will show you how to:
1. Start the mcpjungle server locally using docker compose
2. Add an MCP server in mcpjungle
3. Connect your Claude Desktop to mcpjungle to access your MCP tools
Start the server
Fetch thedocker-compose.yaml and start the mcpjungle server:
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.yaml
docker compose up -d
This exposes mcpjungle's streamable http mcp server at http://localhost:8080/mcp by default.
Add an MCP server
1. Download themcpjungle CLI on your local machine either using brew or directly from the Releases Page.
brew install mcpjungle/mcpjungle/mcpjungle
2. Add the context7 MCP server to mcpjungle using the CLI:
mcpjungle register --name context7 --url https://mcp.context7.com/mcp
You should see output similar to this:

Connect to mcpjungle
In your Claude Desktop, add the configuration for mcpjungle MCP server:
{
"mcpServers": {
"mcpjungle": {
"command": "npx",
"args": [
"mcp-remote",
"http://localhost:8080/mcp",
"--allow-http"
]
}
}
}
Once you have added the configuration, try asking claude something simple:
Use context7 to get the documentation for /lodash/lodash
Claude will then attempt to call the context7__get-library-docs tool via MCPJungle, which will return the documentation for the Lodash library.
<p align="center">

</p>
You now have a working MCP setup with a single unified endpoint!
Next, explore the complete documentation at docs.mcpjungle.com and the public roadmap.
---
<details>
<summary>Legacy README reference</summary>
π Table of Contents
- Installation
- Usage
- Server
- Running mcpjungle server inside Docker
- Running mcpjungle server directly on the host machine
- Shutting down the server
- Client
- Adding Streamable HTTP-based MCP servers
- Adding STDIO-based MCP servers
- Removing MCP servers
- Custom URL for server
- Cold-start problem & Stateful Connections
- Connect to mcpjungle from Claude
- Connect to mcpjungle from Cursor
- Connect to mcpjungle from Copilot
- Enabling/Disabling Tools globally
- Prompts
- Tool Groups
- Authentication
- Enterprise features
- Access Control
- OpenTelemetry
- Limitations
- Contributing
Installation
MCPJungle is shipped as a stand-alone binary.You can either download it from the Releases Page or use Homebrew to install it:
brew install mcpjungle/mcpjungle/mcpjungle
Verify your installation by running
mcpjungle version
> [!IMPORTANT]
> On MacOS, you will have to use homebrew because the compiled binary is not Notarized yet.
MCPJungle provides a Docker image which is useful for running the registry server (more about it later).
docker pull ghcr.io/mcpjungle/mcpjungle
Usage
MCPJungle has a Client-Server architecture and the binary lets you run both the Server and the Client.Server
The MCPJungle server is responsible for managing all the MCP servers registered in it and providing a unified MCP gateway for AI Agents to discover and call tools provided by these registered servers.The gateway itself runs over streamable http transport and is accessible at the /mcp endpoint.
Running inside Docker
For running the MCPJungle server locally, docker compose is the recommended way:# docker-compose.yaml is optimized for individuals running mcpjungle on their local machines for personal use.
mcpjungle will run in development mode by default.
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.yaml
docker compose up -d
docker-compose.prod.yaml is optimized for orgs deploying mcpjungle on a remote server for multiple users.
mcpjungle will run in enterprise mode by default, which enables enterprise features.
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.prod.yaml
docker compose -f docker-compose.prod.yaml up -d
> [!NOTE]
> The enterprise mode used to be called production mode.
> The mode has now been renamed for clarity. Everything else remains the same.
β¦
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.



