MCPJungle

https://docs.mcpjungle.com
Admin
MCPJungle is a self-hosted MCP gateway that allows developers and teams to manage multiple MCP...
Tokens:33,042
Snippets:527
Trust Score:4.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Quick Start Development Environment Setup

Source: https://docs.mcpjungle.com/developers/development

Clones the MCPJungle repository, starts the Docker Compose services, and builds a local development binary. Ensure Go, Docker, and Docker Compose are installed.

```bash
git clone https://github.com/mcpjungle/MCPJungle.git
cd MCPJungle

docker-compose up -d

goreleaser build --single-target --clean --snapshot
```

--------------------------------

### Start Mcpjungle with Docker Compose

Source: https://docs.mcpjungle.com/

Pull the Docker Compose file and start Mcpjungle with a persistent Postgres database. Ensure you have Docker installed and running.

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

--------------------------------

### Example Server List Request

Source: https://docs.mcpjungle.com/reference/api-overview

This example shows how to use curl to request a list of servers from the API, including the necessary authorization header.

```bash
curl http://localhost:8080/api/v0/servers \
  -H "Authorization: Bearer YOUR_TOKEN"
```

--------------------------------

### Example Claude Desktop Prompt

Source: https://docs.mcpjungle.com/quickstart

An example prompt to ask Claude to use the context7 tool via Mcpjungle to retrieve documentation for the lodash library.

```text
Use context7 to get the documentation for `/lodash/lodash`
```

--------------------------------

### Example Canonical Names for Tools and Prompts

Source: https://docs.mcpjungle.com/core-concepts

These examples illustrate how tools and prompts are represented with canonical names, combining server and item names.

```text
context7__get-library-docs
```

```text
filesystem__read_file
```

```text
huggingface__Model Details
```

--------------------------------

### Example Canonical Resource URI

Source: https://docs.mcpjungle.com/core-concepts

This is an example of a canonical resource URI, demonstrating the format for accessing resources through Mcpjungle.

```text
mcpj://res/foo_mcp/ZmlsZTovL3NhbXBsZS50eHQ
```

--------------------------------

### Example: NPX Filesystem STDIO Server Configuration

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

Configuration for the official MCP filesystem server using npx. Supports stateless session mode.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "description": "Filesystem MCP server",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
  "session_mode": "stateless"
}
```

--------------------------------

### Start mcpjungle with default SQLite

Source: https://docs.mcpjungle.com/deployment/database

When no database configuration is provided, Mcpjungle automatically creates a SQLite file named mcpjungle.db in the directory where the process is started. SQLite requires no setup and works well for individuals running Mcpjungle locally.

```bash
mcpjungle start
# Creates ./mcpjungle.db in the current directory
```

--------------------------------

### Initialize Mcpjungle Server for Enterprise

Source: https://docs.mcpjungle.com/reference/cli-server

Prepares the Mcpjungle server for enterprise use by creating the first admin user and storing configuration. Run this once after starting the server in enterprise mode.

```bash
mcpjungle init-server [--registry <url>]
```

```bash
mcpjungle --registry http://your-server:8080 init-server
```

--------------------------------

### Start MCP Inspector

Source: https://docs.mcpjungle.com/developers/development

Launches the MCP Inspector tool using npx, which is useful for testing and debugging MCP interactions. Ensure Node.js and npm are installed.

```bash
npx @modelcontextprotocol/inspector
```

--------------------------------

### Start mcpjungle in enterprise mode via CLI

Source: https://docs.mcpjungle.com/deployment/production

Use the `--enterprise` flag to start mcpjungle in enterprise mode directly from the command line.

```bash
mcpjungle start --enterprise
```

--------------------------------

### Register a STDIO server config file

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

Create a JSON file describing the STDIO server. This example is for the official MCP filesystem server.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "description": "Filesystem MCP server",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
}
```

--------------------------------

### Example: UVX Custom STDIO Server Configuration

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

Configuration for a custom STDIO server using uvx. Supports stateful session mode and environment variable substitution for API tokens and workspace IDs.

```json
{
  "name": "my-stdio-server",
  "transport": "stdio",
  "description": "Custom uvx-based server",
  "command": "uvx",
  "args": ["my-server", "--workspace", "${WORKSPACE_ID}"],
  "session_mode": "stateful",
  "env": {
    "API_TOKEN": "${API_TOKEN}"
  }
}
```

--------------------------------

### Register Server with CLI Flags

Source: https://docs.mcpjungle.com/guides/register-http-servers

Use the `register` command with inline flags for quick server registration. This is suitable for simple setups without authentication or custom headers.

```bash
mcpjungle register --name context7 --url https://mcp.context7.com/mcp
```

```bash
mcpjungle register --name calculator --description "Provides some basic math tools" --url http://127.0.0.1:5000/mcp
```

```bash
mcpjungle register --name calculator --description "Provides some basic math tools" --url http://host.docker.internal:5000/mcp
```

--------------------------------

### Start mcpjungle in enterprise mode via Environment Variable

Source: https://docs.mcpjungle.com/deployment/production

Set the `SERVER_MODE` environment variable to `enterprise` before starting mcpjungle to enable enterprise mode.

```bash
export SERVER_MODE=enterprise
mcpjungle start
```

--------------------------------

### Example Prometheus Metrics Output

Source: https://docs.mcpjungle.com/deployment/observability

This example shows the format of the metrics exposed by mcpjungle, including counters and histograms with relevant labels.

```text
# HELP mcpjungle_tool_calls_ratio_total Total number of tool calls
# TYPE mcpjungle_tool_calls_ratio_total counter
mcpjungle_tool_calls_ratio_total{mcp_server_name="calculator",tool_name="add",outcome="success"} 42

# HELP mcpjungle_tool_call_latency_seconds Latency of tool calls in seconds
# TYPE mcpjungle_tool_call_latency_seconds histogram
mcpjungle_tool_call_latency_seconds_count{mcp_server_name="calculator",tool_name="add",outcome="success"} 42
```

--------------------------------

### Start mcpjungle in development mode

Source: https://docs.mcpjungle.com/deployment/docker

Starts the mcpjungle server and its dependencies in detached mode.

```bash
docker compose up -d
```

--------------------------------

### Verify Mcpjungle Installation

Source: https://docs.mcpjungle.com/installation

Run this command after installation to verify that the Mcpjungle CLI is installed correctly and accessible in your PATH.

```bash
mcpjungle version
```

--------------------------------

### Register Minimal STDIO Server

Source: https://docs.mcpjungle.com/guides/register-popular-servers

The canonical example of local STDIO registration. This pattern is useful for local tools that do not require extra secrets or long-lived sessions.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
  "description": "Filesystem MCP server"
}
```

--------------------------------

### Register MCP Server with JSON Config

Source: https://docs.mcpjungle.com/guides/register-popular-servers

Use this command to register any JSON example configuration file with Mcpjungle.

```bash
mcpjungle register -c ./<filename>.json
```

--------------------------------

### Configure Filesystem MCP Server

Source: https://docs.mcpjungle.com/developers/development

Example JSON configuration for a filesystem MCP server. It specifies the transport, command, and arguments, including paths that should match Docker volume mounts.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "description": "filesystem mcp server",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/host/home"]
}
```

--------------------------------

### Start Mcpjungle Server

Source: https://docs.mcpjungle.com/installation

Run this command to start the Mcpjungle gateway server directly on your host machine. It defaults to port 8080.

```bash
mcpjungle start
```

--------------------------------

### Install Mcpjungle via Homebrew

Source: https://docs.mcpjungle.com/installation

Use this command to install the Mcpjungle CLI on macOS and Linux using Homebrew. This is the recommended method for these platforms.

```bash
brew install mcpjungle/mcpjungle/mcpjungle
```

--------------------------------

### Get Resource Metadata

Source: https://docs.mcpjungle.com/guides/manage-resources

Use the `get resource` command with a resource URI to inspect its metadata. Ensure you have the correct resource URI.

```bash
mcpjungle get resource mcpj://res/mintlify-mcpjungle/bWludGxpZnk6Ly9za2lsbHMvbWNwanVuZ2xl
```

--------------------------------

### Get Prompt

Source: https://docs.mcpjungle.com/reference/cli-tools

Retrieves a prompt template and optionally renders it with arguments.

```APIDOC
## get prompt

Retrieves a prompt template and optionally renders it with arguments.

### Usage
```bash
mcpjungle get prompt <prompt-name> [--arg key=value ...]
```

### Example
```bash
mcpjungle get prompt github__code-review \
  --arg code="def hello(): print('world')" \
  --arg language="python"
```

The output shows the generated structured messages returned by the upstream MCP server.
```

--------------------------------

### User Configuration File for Token Supply

Source: https://docs.mcpjungle.com/governance/clients-and-users

Define user properties, including token supply strategies, within a JSON configuration file. This example shows explicit token assignment and a reference to a file or environment variable for the token.

```json
{
  "name": "charlie",
  "access_token": "charlies_secret_token",
  "access_token_ref": {
    "file": "/path/to/token-file.txt",
    "env": "ENV_VAR_NAME"
  }
}
```

--------------------------------

### List Registered MCP Servers via Docker Exec

Source: https://docs.mcpjungle.com/deployment/docker

An example of running a specific mcpjungle CLI command to list registered servers from within a container named 'mcpjungle-server'.

```bash
docker exec -it mcpjungle-server /mcpjungle list servers
```

--------------------------------

### Get Mcpjungle Version

Source: https://docs.mcpjungle.com/reference/cli-server

Prints version information for the CLI binary and the connected Mcpjungle server. Displays server URL if reachable.

```bash
mcpjungle version
```

```text
CLI Version: v1.2.3
Server Version: v1.2.3
Server URL:  http://127.0.0.1:8080
```

--------------------------------

### List Tools with Custom Registry URL

Source: https://docs.mcpjungle.com/installation

Example of using the --registry flag to specify a custom URL for the Mcpjungle server when running CLI commands. This is useful if your server is not running on the default address.

```bash
mcpjungle --registry http://my-server:9000 list tools
```

--------------------------------

### Create MCP Clients for Agents and Apps

Source: https://docs.mcpjungle.com/reference/cli-enterprise

Create an MCP client, for example, 'claude-desktop', and specify which upstream MCP servers it is allowed to connect to, such as 'github'. This command is used to set up clients that interact with MCP services.

```bash
mcpjungle create mcp-client claude-desktop --allow "github"
```

--------------------------------

### Start mcpjungle in enterprise mode via Docker Compose

Source: https://docs.mcpjungle.com/deployment/production

Utilize the production Docker Compose file, which defaults to `SERVER_MODE=enterprise`, to launch mcpjungle in enterprise mode.

```bash
docker compose -f docker-compose.prod.yaml up -d
```

--------------------------------

### Get Prompt Template

Source: https://docs.mcpjungle.com/reference/cli-tools

Retrieves a prompt template and optionally renders it with arguments. Arguments are passed as key-value pairs using the `--arg` flag.

```bash
mcpjungle get prompt <prompt-name> [--arg key=value ...]
```

```bash
mcpjungle get prompt github__code-review \
  --arg code="def hello(): print('world')" \
  --arg language="python"
```

--------------------------------

### Configure Docker Volume Mounts

Source: https://docs.mcpjungle.com/developers/development

Example of narrowing Docker volume mounts in `docker-compose.yaml` to control filesystem access within containers. Paths are mounted from the host into the container.

```yaml
volumes:
  - ${HOME}:/host/home:ro
  - /path/to/your/project:/host/project:ro
  - /tmp:/host/tmp:rw
```

--------------------------------

### Metadata Endpoint

Source: https://docs.mcpjungle.com/reference/api-overview

The GET /metadata endpoint returns the current running server version.

```json
{ "version": "0.4.2" }
```

--------------------------------

### Enable Metrics in Development Mode

Source: https://docs.mcpjungle.com/deployment/observability

Set environment variables to enable OpenTelemetry metrics in development mode before starting mcpjungle. This is useful for local testing and debugging.

```bash
export OTEL_ENABLED=true
export OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=development

mcpjungle start
```

--------------------------------

### Read Resource Contents

Source: https://docs.mcpjungle.com/guides/manage-resources

Add the `--read` flag to the `get resource` command to retrieve the actual contents of a resource. Mcpjungle will resolve the URI and fetch the data from the owning server.

```bash
mcpjungle get resource --read mcpj://res/mintlify-mcpjungle/bWludGxpZnk6Ly9za2lsbHMvbWNwanVuZ2xl
```

--------------------------------

### Initialize Enterprise Server

Source: https://docs.mcpjungle.com/reference/cli-enterprise

Run this once to bootstrap a new enterprise deployment. It creates the first admin user, generates an admin access token, and stores server details locally. Store generated credentials securely.

```bash
mcpjungle --registry http://your-server:8080 init-server
```

--------------------------------

### Get Resource Metadata or Contents

Source: https://docs.mcpjungle.com/reference/cli-tools

Retrieves resource metadata or reads the resource contents. Use the `--read` flag to fetch the content. Text content is printed inline; blob content may be saved to a file.

```bash
mcpjungle get resource <uri>
```

```bash
mcpjungle get resource --read <uri>
```

```bash
# View metadata
mcpjungle get resource mcpj://res/mintlify-mcpjungle/bWludGxpZnk6Ly9za2lsbHMvbWNwanVuZ2xl
```

```bash
# Read the contents
mcpjungle get resource --read mcpj://res/mintlify-mcpjungle/bWludGxpZnk6Ly9za2lsbHMvbWNwanVuZ2xl
```

--------------------------------

### Register Server from Config File

Source: https://docs.mcpjungle.com/guides/register-http-servers

Register a server using a JSON configuration file, which is recommended for servers requiring authentication or custom headers. This method also allows for keeping registration configurations in version control.

```bash
mcpjungle register -c ./deepwiki.json
```

--------------------------------

### Initialize mcpjungle server for enterprise mode

Source: https://docs.mcpjungle.com/deployment/docker

Initializes the server by creating an admin user and storing its access token. This should be run after the first boot of the production server.

```bash
mcpjungle init-server
```

--------------------------------

### Create an MCP client for Claude Desktop (Enterprise Mode)

Source: https://docs.mcpjungle.com/integrations/claude

Use the Mcpjungle CLI to create a client for Claude Desktop in enterprise mode. This command outputs an access token required for authentication.

```bash
mcpjungle create mcp-client claude-desktop --allow "server1, server2"
```

--------------------------------

### Create a User Account Configuration

Source: https://docs.mcpjungle.com/reference/config-file

Define a user account with a name and access token. Tokens must be supplied via `access_token` or `access_token_ref` when using a config file.

```json
{
  "name": "charlie",
  "access_token": "charlies_secret_token",
  "access_token_ref": {
    "file": "/path/to/token-file.txt",
    "env": "CHARLIE_TOKEN"
  }
}
```

--------------------------------

### Create an MCP client from a configuration file

Source: https://docs.mcpjungle.com/governance/access-control

Use the `create mcp-client --conf` command to create a client based on a JSON configuration file. When using a config file, a token must be explicitly provided; Mcpjungle cannot auto-generate one in this workflow.

```bash
mcpjungle create mcp-client --conf ./cursor-local.json
```

--------------------------------

### Get a tool group definition

Source: https://docs.mcpjungle.com/reference/cli-groups

Use the `get group` command followed by the group name to view its stored definition and exposed endpoint URLs. Note that disabled or removed tools will still appear in the definition.

```bash
mcpjungle get group <name>
```

```bash
mcpjungle get group engineering-tools
```

--------------------------------

### Get Resource

Source: https://docs.mcpjungle.com/reference/cli-tools

Retrieves resource metadata or reads the resource contents.

```APIDOC
## get resource

Retrieves resource metadata, or reads the resource contents.

### Usage
```bash
mcpjungle get resource <uri>
mcpjungle get resource --read <uri>
```

### Examples
```bash
# View metadata
mcpjungle get resource mcpj://res/mintlify-mcpjungle/bWludGxpZnk6Ly9za2lsbHMvbWNwanVuZ2xl

# Read the contents
mcpjungle get resource --read mcpj://res/mintlify-mcpjungle/bWludGxpZnk6Ly9za2lsbHMvbWNwanVuZ2xl
```

With `--read`, text content is printed inline. Blob content may be decoded and written to a file in the current working directory.
```

--------------------------------

### Register a STDIO Server

Source: https://docs.mcpjungle.com/reference/config-file

Configure this to register a server that communicates via standard input/output. Specify the `command` to execute the server process and optionally provide `args`, `env` variables, and `session_mode` for process management.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "description": "Filesystem MCP server",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
  "env": {
    "KEY": "value"
  },
  "session_mode": "stateless"
}
```

--------------------------------

### Health Check Endpoint

Source: https://docs.mcpjungle.com/reference/api-overview

The GET /health endpoint returns a 200 OK status when the server is running.

```json
{ "status": "ok" }
```

--------------------------------

### Build Single Binary with Goreleaser

Source: https://docs.mcpjungle.com/developers/development

Builds a single binary for your current system using goreleaser. Use --clean to remove temporary files and --snapshot for a local build without publishing.

```bash
goreleaser build --single-target --clean --snapshot
```

--------------------------------

### Create Tool Group: Cherry-pick specific tools

Source: https://docs.mcpjungle.com/guides/tool-groups

Use `included_tools` to handpick exactly which tools to expose. Tool names follow the canonical format `<server-name>__<tool-name>`. Run `mcpjungle list tools` to see all available tool names.

```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"
  ]
}
```

--------------------------------

### Create an MCP Client Configuration

Source: https://docs.mcpjungle.com/reference/config-file

Configure an MCP client with allowed servers and an access token. Tokens must be supplied via `access_token` or `access_token_ref` when using a config file.

```json
{
  "name": "cursor-local",
  "allowed_servers": ["calculator", "github"],
  "access_token": "my_secret_token_123",
  "access_token_ref": {
    "file": "/run/secrets/mcpjungle_token",
    "env": "MCPJUNGLE_CLIENT_TOKEN"
  }
}
```

--------------------------------

### Build Release Binaries for All Platforms with Goreleaser

Source: https://docs.mcpjungle.com/developers/development

Generates release binaries for all supported platforms. Use --snapshot for a local build and --clean to remove temporary files.

```bash
goreleaser release --snapshot --clean
```

--------------------------------

### List Available Resources

Source: https://docs.mcpjungle.com/guides/manage-resources

Use the `list resources` command to discover available resource URIs. This is useful for finding the URIs needed for other commands.

```bash
mcpjungle list resources
```

--------------------------------

### Create an MCP client with specific server access

Source: https://docs.mcpjungle.com/governance/access-control

Use the `create mcp-client` command to generate a new client identity and specify the servers it can access using the `--allow` flag. If `--allow` is omitted, the client will not be able to access any servers.

```bash
mcpjungle create mcp-client cursor-local --allow "calculator, github"
```

--------------------------------

### Show Tool Usage

Source: https://docs.mcpjungle.com/reference/cli-tools

Displays the input schema for a tool before invocation. This includes the tool description, argument types, required fields, and any JSON-schema constraints.

```bash
mcpjungle usage <tool-name>
```

```bash
mcpjungle usage github__create_issue
```

--------------------------------

### Configure Claude Desktop with Mcpjungle

Source: https://docs.mcpjungle.com/integrations/claude

Add this configuration to your Claude Desktop's `claude_desktop_config.json` to connect to Mcpjungle. The `--allow-http` flag is necessary for local HTTP connections.

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

--------------------------------

### Inspect a Specific Tool Group

Source: https://docs.mcpjungle.com/guides/tool-groups

Use `get group <group-name>` to retrieve detailed information about a specific tool group, including its endpoint URLs and associated tools.

```bash
mcpjungle get group claude-tools
```

--------------------------------

### Register STDIO Server with Environment Variables

Source: https://docs.mcpjungle.com/guides/register-popular-servers

Some STDIO servers need environment variables at process startup. Secrets can be added the same way using environment variable injection.

```json
{
  "name": "n8n",
  "transport": "stdio",
  "command": "npx",
  "args": ["-y", "n8n-mcp"],
  "description": "n8n MCP server",
  "env": {
    "MCP_MODE": "stdio",
    "LOG_LEVEL": "error"
  }
}
```

```json
{
  "env": {
    "API_KEY": "${N8N_API_KEY}"
  }
}
```

--------------------------------

### Create User

Source: https://docs.mcpjungle.com/reference/cli-enterprise

Creates a standard user account for a human operator. Use flags for direct configuration or `--conf` for a JSON config file. When using `--conf`, a custom token must be provided via `access_token` or `access_token_ref`.

```bash
mcpjungle create user <username> [flags]
```

```bash
mcpjungle create user --conf <file>
```

```bash
# Let mcpjungle generate the token
mcpjungle create user alice
```

```bash
# Supply your own token
mcpjungle create user alice --access-token alice-custom-token
```

```json
{
  "name": "alice",
  "access_token_ref": {
    "env": "ALICE_ACCESS_TOKEN"
  }
}
```

--------------------------------

### Create Tool Group: Mix both approaches

Source: https://docs.mcpjungle.com/guides/tool-groups

Combine `included_tools`, `included_servers`, and `excluded_tools` for maximum flexibility. Exclusion runs last regardless of the order fields appear in the file.

```json
{
  "name": "comprehensive-tools",
  "description": "Mix of manual tools, server inclusion, and exclusions",
  "included_tools": ["filesystem__read_file"],
  "included_servers": ["time"],
  "excluded_tools": ["time__convert_time"]
}
```

--------------------------------

### Enable Tool, Prompt, or Server

Source: https://docs.mcpjungle.com/reference/cli-tools

Enables tools, prompts, or entire servers globally. Use the subcommand `tool`, `prompt`, or `server` followed by the name.

```bash
mcpjungle enable <subcommand> <name>
```

```bash
mcpjungle enable tool github__create_issue
```

```bash
mcpjungle enable tool github
```

```bash
mcpjungle enable prompt github
```

```bash
mcpjungle enable server github
```

--------------------------------

### List Tools by Server

Source: https://docs.mcpjungle.com/reference/cli-tools

Lists all tools available through the gateway, filtered to a specific registered server.

```bash
mcpjungle list tools --server <name>
```

--------------------------------

### Verify Server Registration and Usage

Source: https://docs.mcpjungle.com/guides/register-http-servers

Use `mcpjungle list tools` to see registered servers, `mcpjungle usage` to inspect tool schemas, and `mcpjungle invoke` to call tools.

```bash
mcpjungle list tools

# get the usage schema of a tool
mcpjungle usage deepwiki__read_wiki_structure

# call a tool from cli
mcpjungle invoke deepwiki__read_wiki_structure --input '{"repoName": "facebook/react"}'
```

--------------------------------

### Login to Enterprise Server

Source: https://docs.mcpjungle.com/reference/cli-enterprise

Stores an existing access token in the configuration file for future CLI authentication. Regular users run this after an administrator creates their account and provides a token.

```bash
mcpjungle login <access-token>
```

```bash
mcpjungle login eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
```

--------------------------------

### Run mcpjungle with Docker in production

Source: https://docs.mcpjungle.com/deployment/production

Deploy the standard mcpjungle Docker image for production, configuring the database connection via the `DATABASE_URL` environment variable.

```bash
docker run -d \
  --name mcpjungle-server \
  -e SERVER_MODE=enterprise \
  -e DATABASE_URL=postgres://user:password@your-db-host:5432/mcpjungle \
  -p 8080:8080 \
  ghcr.io/mcpjungle/mcpjungle:latest
```

--------------------------------

### Register STDIO server with mcpjungle CLI

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

Pass the configuration file to the `register` command using the `-c` flag to register the STDIO server with mcpjungle.

```bash
mcpjungle register -c ./filesystem.json
```

--------------------------------

### Download Docker Compose file for local development

Source: https://docs.mcpjungle.com/deployment/docker

Use this command to download the docker-compose.yaml file for local development.

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

--------------------------------

### Create a new tool group

Source: https://docs.mcpjungle.com/reference/cli-groups

Use the `create group` command with a JSON configuration file to define a new tool group. The configuration specifies the group's name, description, and which tools and servers to include or exclude.

```bash
mcpjungle create group --conf <file>
```

```json
{
  "name": "engineering-tools",
  "description": "Tools for the engineering agent",
  "included_tools": [
    "github__create_issue",
    "github__list_repos"
  ],
  "included_servers": [
    "jira"
  ],
  "excluded_tools": [
    "jira__delete_project"
  ]
}
```

```bash
mcpjungle create group --conf ./engineering-tools.json
```

--------------------------------

### Download Docker Compose file for production

Source: https://docs.mcpjungle.com/deployment/docker

Use this command to download the docker-compose.prod.yaml file for production deployments.

```bash
curl -O https://raw.githubusercontent.com/mcpjungle/MCPJungle/refs/heads/main/docker-compose.prod.yaml
```

--------------------------------

### Create a Tool Group

Source: https://docs.mcpjungle.com/guides/tool-groups

Use the `create group` command with a configuration file to define a new tool group. This command returns the group's endpoint for client connections.

```bash
mcpjungle create group -c ./claude-tools-group.json
```

--------------------------------

### YAML Client Configuration

Source: https://docs.mcpjungle.com/reference/config-file

The default client configuration file uses YAML syntax to specify the registry URL and access token.

```yaml
registry_url: http://my-server:9000
access_token: 1YHf2LwE1LXtp5lW_vM-gmdYHlPHdqwnILitBhXE4Aw
```

--------------------------------

### Run All Go Tests

Source: https://docs.mcpjungle.com/developers/development

Executes all tests within the project. This is a standard command for verifying code integrity.

```bash
go test ./...
```

--------------------------------

### List Available Tools

Source: https://docs.mcpjungle.com/guides/tools-and-prompts

Use this command to list all tools registered with Mcpjungle. To scope the list to a specific server or Tool Group, use the --server or --group flags respectively.

```bash
mcpjungle list tools
```

```bash
mcpjungle list tools --server context7
```

```bash
mcpjungle list tools --group claude-tools
```

--------------------------------

### Create a Tool Group Configuration

Source: https://docs.mcpjungle.com/reference/config-file

Define a tool group with included and excluded tools and servers. At least one of `included_tools` or `included_servers` must be set to avoid an empty group.

```json
{
  "name": "claude-tools",
  "description": "Tools exposed to Claude Desktop",
  "included_tools": [
    "filesystem__read_file",
    "time__get_current_time"
  ],
  "included_servers": ["deepwiki"],
  "excluded_tools": ["deepwiki__search"]
}
```

--------------------------------

### List Resources

Source: https://docs.mcpjungle.com/reference/cli-tools

Lists resources across all servers or from a specific server. Use the `--server` flag to filter by a particular server.

```bash
mcpjungle list resources
```

```bash
mcpjungle list resources --server mintlify-mcpjungle
```

--------------------------------

### Register Simple HTTP Server with JSON Config

Source: https://docs.mcpjungle.com/guides/register-popular-servers

Use a JSON config file for servers if you prefer to keep registrations in version control, even for simple HTTP servers.

```json
{
  "name": "deepwiki",
  "transport": "streamable_http",
  "url": "https://mcp.deepwiki.com/mcp",
  "description": "DeepWiki MCP server"
}
```

--------------------------------

### List All Prompts

Source: https://docs.mcpjungle.com/reference/cli-tools

Lists all prompts available across all registered MCP servers in the gateway.

```bash
mcpjungle list prompts
```

--------------------------------

### Register STDIO Server with uvx

Source: https://docs.mcpjungle.com/guides/register-popular-servers

Use this JSON configuration to register a Python-based STDIO server using the uvx launcher. This is suitable for small Python-distributed MCP servers.

```json
{
  "name": "time",
  "transport": "stdio",
  "command": "uvx",
  "args": ["mcp-server-time"],
  "description": "Time MCP server",
  "session_mode": "stateful"
}
```

--------------------------------

### Configure PostgreSQL with individual environment variables

Source: https://docs.mcpjungle.com/deployment/database

Set individual Postgres environment variables if you prefer not to construct a full DSN. POSTGRES_HOST is required, while others have sensible defaults. Each credential variable also accepts a _FILE variant for reading values from files.

```bash
# Required
export POSTGRES_HOST=localhost

# Optional (defaults shown)
export POSTGRES_PORT=5432
export POSTGRES_USER=postgres
export POSTGRES_PASSWORD=secret
export POSTGRES_DB=postgres

mcpjungle start
```

```bash
export POSTGRES_HOST=localhost
export POSTGRES_USER_FILE=/run/secrets/pg_user
export POSTGRES_PASSWORD_FILE=/run/secrets/pg_password
export POSTGRES_DB_FILE=/run/secrets/pg_db

mcpjungle start
```

--------------------------------

### List All Tool Groups

Source: https://docs.mcpjungle.com/guides/tool-groups

Execute `list groups` to view all configured tool groups. This command helps in managing and monitoring existing groups.

```bash
mcpjungle list groups
```

--------------------------------

### List Tools

Source: https://docs.mcpjungle.com/reference/cli-tools

Lists available tools. Can be filtered by server or group. Use `--server` to specify a server, or `--group` to list tools active in a specific group.

```bash
# List all tools
mcpjungle list tools
```

```bash
# List tools from one server
mcpjungle list tools --server github
```

```bash
# List tools currently active in a group
mcpjungle list tools --group engineering-tools
```

--------------------------------

### Run Go Tests with Coverage

Source: https://docs.mcpjungle.com/developers/development

Runs all tests and generates a coverage report. This helps identify areas of the codebase that are not adequately tested.

```bash
go test -cover ./...
```

--------------------------------

### Show Tool Usage

Source: https://docs.mcpjungle.com/reference/cli-tools

Shows the input schema for a tool before invoking it, including its description, argument types, and required fields.

```APIDOC
## usage

Shows the input schema for a tool before you invoke it.

### Usage
```bash
mcpjungle usage <tool-name>
```

### Example
```bash
mcpjungle usage github__create_issue
```

The output includes the tool description, argument types, required fields, and any JSON-schema constraints exposed by the upstream MCP server.
```

--------------------------------

### Create an MCP client for Copilot in enterprise mode

Source: https://docs.mcpjungle.com/integrations/copilot

Use the mcpjungle CLI to create a dedicated MCP client for Copilot when running in enterprise mode. This client will be used to authenticate requests.

```bash
mcpjungle create mcp-client copilot-local --allow "server1, server2"
```

--------------------------------

### Use `latest-stdio` Docker Image

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

To run STDIO-based servers that rely on `npx` or `uvx` within the Mcpjungle Docker container, you must use the `latest-stdio` tagged image. The default image is minimal and does not include these tools.

```bash
MCPJUNGLE_IMAGE_TAG=latest-stdio docker compose up -d
```

--------------------------------

### Configure Claude Desktop with Tool Groups

Source: https://docs.mcpjungle.com/integrations/claude

Point Claude Desktop to a Tool Group endpoint instead of the main gateway to provide a curated subset of tools. This helps manage the number of tools visible to Claude.

```json
{
  "mcpServers": {
    "mcpjungle": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8080/v0/groups/claude-tools/mcp",
        "--allow-http"
      ]
    }
  }
}
```

--------------------------------

### Enable Feature

Source: https://docs.mcpjungle.com/reference/cli-tools

Enables tools, prompts, or an entire server globally.

```APIDOC
## enable

Enables tools, prompts, or an entire server globally.

### Usage
```bash
mcpjungle enable <subcommand> <name>
```

Supported forms:
* `mcpjungle enable tool <name>`
* `mcpjungle enable prompt <name>`
* `mcpjungle enable server <name>`

### Examples
```bash
mcpjungle enable tool github__create_issue
mcpjungle enable tool github
mcpjungle enable prompt github
mcpjungle enable server github
```

<Note>
  The legacy form `mcpjungle enable <name>` still works for backward compatibility, but `enable tool <name>` or `enable server <name>` is preferred.
</Note>
```

--------------------------------

### Register MCP Server with CLI Flags

Source: https://docs.mcpjungle.com/guides/register-popular-servers

Use direct CLI flags for servers that only require a name and URL. This is the simplest pattern for hosted Streamable HTTP servers.

```bash
mcpjungle register --name context7 --url https://mcp.context7.com/mcp
```

```bash
mcpjungle register --name todoist --url https://ai.todoist.net/mcp
```

--------------------------------

### Create MCP Client

Source: https://docs.mcpjungle.com/reference/cli-enterprise

Creates an authenticated MCP client identity. Use flags for direct configuration or `--conf` for a JSON config file. When using `--conf`, a custom token must be provided via `access_token` or `access_token_ref`.

```bash
mcpjungle create mcp-client <name> [flags]
```

```bash
mcpjungle create mcp-client --conf <file>
```

```bash
# Let mcpjungle generate the token
mcpjungle create mcp-client claude-desktop --allow "github,jira"
```

```bash
# Supply your own token
mcpjungle create mcp-client my-agent \
  --allow "github" \
  --access-token my-custom-token
```

```json
{
  "name": "claude-desktop",
  "description": "Claude Desktop on Alice's machine",
  "allowed_servers": ["github", "jira"],
  "access_token_ref": {
    "env": "CLAUDE_CLIENT_TOKEN"
  }
}
```

```json
{
  "name": "claude-desktop",
  "allowed_servers": ["github", "jira"],
  "access_token_ref": {
    "file": "/run/secrets/claude-token"
  }
}
```

--------------------------------

### STDIO server config file format

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

The full set of fields for a STDIO server configuration, including name, transport, description, command, arguments, session mode, and environment variables.

```json
{
  "name": "<server-name>",
  "transport": "stdio",
  "description": "<description>",
  "command": "<command>",
  "args": ["<arg1>", "<arg2>"],
  "session_mode": "stateless",
  "env": {
    "KEY": "value"
  }
}
```

--------------------------------

### Set PostgreSQL Connection String

Source: https://docs.mcpjungle.com/reference/environment-variables

Use DATABASE_URL for a full DSN to connect to PostgreSQL. If not set, MCPJungle falls back to SQLite.

```bash
export DATABASE_URL=postgres://admin:root@localhost:5432/mcpjungle_db
```

--------------------------------

### Create an mcp-client for Cursor in enterprise mode

Source: https://docs.mcpjungle.com/integrations/cursor

Use the mcpjungle CLI to create a dedicated MCP client for Cursor when your mcpjungle instance runs in enterprise mode. This command allows specifying which servers the client can access.

```bash
mcpjungle create mcp-client cursor-local --allow "server1, server2"
```

--------------------------------

### Server Metadata

Source: https://docs.mcpjungle.com/reference/api-overview

Returns the running server version.

```APIDOC
## GET /metadata

### Description
Returns the running server version.

### Method
GET

### Endpoint
/metadata

### Response
#### Success Response (200)
- **version** (string) - The current version of the running server.
```

--------------------------------

### Configure Stateful Session Mode

Source: https://docs.mcpjungle.com/guides/session-modes

Set `session_mode` to `"stateful"` in your server configuration to enable stateful connections. This keeps the connection to the upstream server open across multiple tool calls, avoiding repeated startup overhead.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
  "session_mode": "stateful"
}
```

--------------------------------

### Register stdio/sse Server with Config File

Source: https://docs.mcpjungle.com/reference/cli-tools

Registers a stdio or sse MCP server using a JSON configuration file. This is required for non-HTTP transports.

```bash
mcpjungle register --conf ./filesystem.json
```

--------------------------------

### JSON Configuration with Environment Variables

Source: https://docs.mcpjungle.com/reference/config-file

JSON configuration files support environment variable placeholders (e.g., ${VAR_NAME}) which are substituted before the command is executed.

```json
{
  "name": "${MCP_SERVER_NAME}",
  "transport": "streamable_http",
  "url": "https://api.example.com/workspaces/${WORKSPACE_ID}/mcp",
  "bearer_token": "${API_TOKEN}"
}
```

--------------------------------

### Create Tool Group: Include entire servers

Source: https://docs.mcpjungle.com/guides/tool-groups

Use `included_servers` to pull in all tools from one or more servers. Combine with `excluded_tools` to remove specific tools you don't want to expose. Exclusion is always applied after inclusion.

```json
{
  "name": "claude-tools",
  "description": "All tools from time and deepwiki servers except time__convert_time",
  "included_servers": ["time", "deepwiki"],
  "excluded_tools": ["time__convert_time"]
}
```

--------------------------------

### Run GolangCI-Lint

Source: https://docs.mcpjungle.com/developers/development

Executes the golangci-lint static analysis tool to check for code quality and potential issues. This helps maintain code consistency and catch errors early.

```bash
golangci-lint run
```

--------------------------------

### Create an MCP client with a custom access token

Source: https://docs.mcpjungle.com/governance/access-control

You can provide your own access token during client creation using the `--access-token` flag. This is useful for managing tokens externally, such as with Vault or AWS KMS.

```bash
mcpjungle create mcp-client cursor-local --allow "calculator, github" --access-token my_custom_token
```

--------------------------------

### Test Release Assets with Goreleaser

Source: https://docs.mcpjungle.com/developers/development

Tests the full release assets, including binaries and Docker images, without publishing them. Use --clean to remove temporary files and --snapshot for a local test.

```bash
goreleaser release --clean --snapshot --skip publish
```

--------------------------------

### Inspect Tool Usage

Source: https://docs.mcpjungle.com/guides/tools-and-prompts

This command displays the schema and expected input shape for a specific tool, which is useful for understanding how to invoke it correctly.

```bash
mcpjungle usage deepwiki__read_wiki_structure
```

--------------------------------

### Create MCP Users with Different Token Strategies

Source: https://docs.mcpjungle.com/governance/clients-and-users

Use the `mcpjungle create user` command to create new user accounts. You can specify an auto-generated token, a custom token, or create a user from a configuration file.

```bash
mcpjungle create user bob
```

```bash
mcpjungle create user alice --access-token alice_token_123
```

```bash
mcpjungle create user --conf /path/to/user-config.json
```

--------------------------------

### Create Git Tag for Release

Source: https://docs.mcpjungle.com/developers/development

Creates an annotated Git tag for a specific release version and pushes it to the origin. Replace `0.1.0` with your desired version number.

```bash
git tag -a 0.1.0 -m "Release version 0.1.0"
git push origin 0.1.0
```

--------------------------------

### Create User Accounts for Operators

Source: https://docs.mcpjungle.com/reference/cli-enterprise

Create a user account, for instance, 'alice', for operators. This command is used to manage user access to the MCP Jungle system.

```bash
mcpjungle create user alice
```

--------------------------------

### Configure STDIO Server Authentication via Environment Variables

Source: https://docs.mcpjungle.com/governance/upstream-authentication

For STDIO-based MCP servers, authentication credentials can be passed through environment variables defined in the server's JSON configuration. The STDIO server process will inherit these variables.

```json
{
  "name": "my-stdio-server",
  "transport": "stdio",
  "command": "uvx",
  "args": ["my-server"],
  "env": {
    "API_TOKEN": "${API_TOKEN}"
  }
}
```

--------------------------------

### Register an MCP server from Docker on macOS/Windows

Source: https://docs.mcpjungle.com/deployment/docker

When running mcpjungle inside Docker on macOS or Windows, use 'host.docker.internal' to reach services running on the host machine.

```bash
mcpjungle register --name calculator --url http://host.docker.internal:5000/mcp
```

--------------------------------

### List Prompts from Specific Server

Source: https://docs.mcpjungle.com/reference/cli-tools

Lists prompts available from a single, specified registered MCP server.

```bash
mcpjungle list prompts --server github
```

--------------------------------

### Register Server with Bearer Token (CLI)

Source: https://docs.mcpjungle.com/guides/register-http-servers

Use the `--bearer-token` flag to authenticate with SaaS-hosted MCP servers requiring a static API token.

```bash
mcpjungle register \
  --name huggingface \
  --description "HuggingFace MCP Server" \
  --url https://huggingface.co/mcp \
  --bearer-token <your-hf-api-token>
```

--------------------------------

### Register Context7 MCP Server

Source: https://docs.mcpjungle.com/quickstart

Register the Context7 MCP server with Mcpjungle using the CLI. Provide a name and the URL for the MCP server.

```bash
mcpjungle register --name context7 --url https://mcp.context7.com/mcp
```

--------------------------------

### Retrieve a Prompt with Arguments

Source: https://docs.mcpjungle.com/guides/tools-and-prompts

Retrieve a specific prompt for testing and debugging via the CLI. Use the --arg flag for each prompt argument, specifying the key and value.

```bash
mcpjungle get prompt "huggingface__Model Details" --arg model_id="openai/gpt-oss-120b"
```

--------------------------------

### Configure Cursor client with access token

Source: https://docs.mcpjungle.com/governance/access-control

When integrating with Cursor, include the MCP client's access token in the `Authorization` header within the `mcpServers` configuration.

```json
{
  "mcpServers": {
    "mcpjungle": {
      "url": "http://localhost:8080/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ACCESS_TOKEN"
      }
    }
  }
}
```

--------------------------------

### Inspect SQLite Database Tables

Source: https://docs.mcpjungle.com/developers/development

Connects to the local SQLite database file `mcpjungle.db` and lists all available tables. This is useful for inspecting the database schema and content during local development.

```bash
sqlite3 mcpjungle.db

.tables
```

--------------------------------

### Configure Filesystem Access for STDIO Server in Docker

Source: https://docs.mcpjungle.com/guides/register-stdio-servers

When running Mcpjungle in Docker, mount the host directory you want to expose to the container. Use `/host` as the target directory in your configuration to grant the filesystem server access to your current working directory on the host.

```json
{
  "name": "filesystem",
  "transport": "stdio",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/host"]
}
```

--------------------------------

### Query SQLite Database Table

Source: https://docs.mcpjungle.com/developers/development

Connects to the local SQLite database file `mcpjungle.db` and selects all rows from the `tools` table. Use this to view data within your database.

```bash
sqlite3 mcpjungle.db

SELECT * FROM tools;
```

--------------------------------

### MCP client configuration object with token supply strategies

Source: https://docs.mcpjungle.com/governance/access-control

Define an MCP client's configuration, including its name, allowed servers, and access token. The `access_token_ref` property allows specifying token sources from a file or environment variable.

```json
{
  "name": "cursor-local",
  "allowed_servers": ["calculator", "github"],
  "access_token": "my_secret_token_123",
  "access_token_ref": {
    "file": "/path/to/token-file.txt",
    "env": "ENV_VAR_NAME"
  }
}
```

--------------------------------

### List Resources

Source: https://docs.mcpjungle.com/reference/cli-tools

Lists resources across all servers or from a specific server.

```APIDOC
## list resources

Lists resources across all servers or from one server.

### Usage
```bash
mcpjungle list resources
mcpjungle list resources --server <server-name>
```
```

--------------------------------

### Set PostgreSQL Password from File

Source: https://docs.mcpjungle.com/reference/environment-variables

Provide the PostgreSQL password via a file, useful for Docker secrets.

```bash
export POSTGRES_PASSWORD_FILE=/run/secrets/pg_password
```

--------------------------------

### Run Go Tests for a Specific Package

Source: https://docs.mcpjungle.com/developers/development

Executes tests only for the specified package. Useful for targeted testing during development.

```bash
go test ./internal/service/mcp
```

--------------------------------

### Register Upstream Server for Interactive OAuth (CLI)

Source: https://docs.mcpjungle.com/governance/upstream-authentication

Initiates an interactive CLI registration process for upstream MCP servers that require OAuth. The CLI will open a browser for user approval if the server advertises OAuth.

```bash
mcpjungle register --name todoist --url https://ai.todoist.net/mcp
```

--------------------------------

### Minimal Streamable HTTP MCP Server Config

Source: https://docs.mcpjungle.com/reference/cli-tools

A minimal JSON configuration for registering a streamable HTTP MCP server. Ensure the URL points to a valid MCP endpoint.

```json
{
  "name": "calculator",
  "transport": "streamable_http",
  "description": "Basic math tools",
  "url": "http://127.0.0.1:8000/mcp",
  "session_mode": "stateless"
}
```

--------------------------------

### Run Mcpjungle CLI Commands via Kubectl Exec

Source: https://docs.mcpjungle.com/deployment/docker

Execute the mcpjungle binary directly within a running Kubernetes pod. Replace `<namespace>` with your namespace and `<pod_name>` with your pod's name.

```bash
kubectl -n <namespace> exec -it po/<pod_name> -- /mcpjungle
```

--------------------------------

### Configure Upstream Server with Bearer Token (Config File)

Source: https://docs.mcpjungle.com/governance/upstream-authentication

Specify the bearer token directly in the server's JSON configuration file for authentication.

```json
{
  "name": "huggingface",
  "transport": "streamable_http",
  "url": "https://huggingface.co/mcp",
  "description": "HuggingFace MCP Server",
  "bearer_token": "<your-hf-api-token>"
}
```

--------------------------------

### List Prompts

Source: https://docs.mcpjungle.com/guides/tools-and-prompts

List all registered prompts. You can filter the list by a specific server using the --server flag.

```bash
mcpjungle list prompts
```

```bash
mcpjungle list prompts --server huggingface
```

--------------------------------

### Set PostgreSQL Database Name

Source: https://docs.mcpjungle.com/reference/environment-variables

Define the PostgreSQL database name. Defaults to 'postgres'.

```bash
export POSTGRES_DB=postgres
```

--------------------------------

### Release with Goreleaser and Docker Login

Source: https://docs.mcpjungle.com/developers/development

Releases the project using goreleaser after logging into Docker Hub with a provided GitHub token. This command publishes release artifacts and the Homebrew distribution.

```bash
export GITHUB_TOKEN="<your GH token>"
echo $GITHUB_TOKEN | docker login ghcr.io -u <your-github-username> --password-stdin

goreleaser release --clean
```

--------------------------------

### Set PostgreSQL Host

Source: https://docs.mcpjungle.com/reference/environment-variables

Specify the PostgreSQL host when using individual POSTGRES_* variables. Required if DATABASE_URL is not set.

```bash
export POSTGRES_HOST=localhost
```

--------------------------------

### Set PostgreSQL Database Name from File

Source: https://docs.mcpjungle.com/reference/environment-variables

Provide the PostgreSQL database name via a file, useful for Docker secrets.

```bash
export POSTGRES_DB_FILE=/run/secrets/pg_db
```

--------------------------------

### Set PostgreSQL User

Source: https://docs.mcpjungle.com/reference/environment-variables

Define the PostgreSQL username. Defaults to 'postgres'.

```bash
export POSTGRES_USER=postgres
```
Tokens:
Raw