MCPJungle

📋 Tabla de contenidos

• Instalación
• Uso
  • Servidor
    • Ejecutar el servidor mcpjungle dentro de Docker
    • Ejecutar el servidor mcpjungle directamente en la máquina host
    • Apagar el servidor
  • Cliente
    • Añadir servidores MCP basados en HTTP transmisible
    • Añadir servidores MCP basados en STDIO
    • Eliminar servidores MCP
    • URL personalizada para el servidor
  • Problema de arranque en frío y conexiones con estado
  • Conectarse a mcpjungle desde Claude
  • Conectarse a mcpjungle desde Cursor
  • Conectarse a mcpjungle desde Copilot
  • Habilitar/Deshabilitar herramientas globalmente
  • Prompts
  • Grupos de herramientas
  • Autenticación
  • Características empresariales
    • Control de acceso
    • OpenTelemetry
• Limitaciones
• Contribuir

Instalación

MCPJungle se distribuye como un binario independiente.

Puedes descargarlo desde la página de Releases o usar Homebrew para instalarlo:

brew install mcpjungle/mcpjungle/mcpjungle

Verifica tu instalación ejecutando

mcpjungle version

[!IMPORTANT] En MacOS, tendrás que usar homebrew porque el binario compilado aún no está notarizado.

MCPJungle proporciona una imagen Docker que es útil para ejecutar el servidor de registro (más sobre esto más adelante).

docker pull ghcr.io/mcpjungle/mcpjungle

Uso

MCPJungle tiene una arquitectura Cliente-Servidor y el binario te permite ejecutar tanto el Servidor como el Cliente.

Servidor

El servidor MCPJungle es responsable de gestionar todos los servidores MCP registrados en él y de proporcionar una pasarela MCP unificada para que los Agentes de IA descubran y llamen a las herramientas proporcionadas por estos servidores registrados.

La pasarela en sí se ejecuta sobre transporte http transmisible y es accesible en el endpoint /mcp.

Ejecución dentro de Docker

Para ejecutar el servidor MCPJungle localmente, docker compose es la forma recomendada:

# 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] El modo enterprise solía llamarse modo production. El modo ha sido renombrado para mayor claridad. Todo lo demás sigue igual.

Esto iniciará el servidor MCPJungle junto con un contenedor persistente de base de datos Postgres.

Puedes verificar rápidamente que el servidor está ejecutándose:

curl http://localhost:8080/health

Si planeas registrar servidores MCP basados en stdio que dependen de npx o uvx, usa la imagen docker de mcpjungle con la etiqueta stdio en su lugar.

MCPJUNGLE_IMAGE_TAG=latest-stdio docker compose up -d

[!NOTE] Si estás usando docker-compose.yaml, esta ya es la etiqueta de imagen por defecto. Solo necesitas especificar la etiqueta de imagen stdio si estás usando docker-compose.prod.yaml.

Esta imagen es significativamente más grande. Pero es muy conveniente y recomendada para ejecutar localmente cuando dependes de servidores MCP basados en stdio.

Por ejemplo, si solo quieres registrar servidores MCP remotos como context7 y deepwiki, puedes usar la imagen estándar (mínima).

Pero si también quieres usar servidores basados en stdio como filesystem, time, github, etc., deberías usar la imagen con la etiqueta stdio en su lugar.

[!NOTE] Si tus servidores stdio dependen de herramientas distintas de npx o uvx, tendrás que crear una imagen docker personalizada que incluya esas dependencias junto con el binario mcpjungle.

Despliegue en producción

La imagen Docker de MCPJungle por defecto es muy ligera: solo contiene una imagen base mínima y el binario mcpjungle.

Por lo tanto, es adecuada y recomendada para despliegues de producción.

Para la base de datos, recomendamos desplegar un clúster Postgres DB separado y proporcionar su endpoint a mcpjungle (consulta la sección Base de datos más abajo).

Puedes ver las definiciones de la imagen Docker estándar y la imagen Docker stdio.

Ejecución directa en el host

También puedes ejecutar el servidor directamente en tu máquina host usando el binario:

mcpjungle start

Esto inicia el servidor de registro principal y la pasarela MCP, accesible en el puerto 8080 por defecto.

Apagado

Es importante que el servidor mcpjungle se apague correctamente para garantizar una limpieza adecuada.

La forma recomendada de detener el proceso del servidor es enviarle una señal SIGTERM.

Base de datos

El servidor mcpjungle depende de una base de datos y, por defecto, crea un archivo SQLite DB mcpjungle.db en el directorio de trabajo actual.

Esto está bien cuando solo estás probando cosas localmente.

Si no proporcionas configuración de PostgreSQL o una ruta SQLite personalizada, mcpjungle usa ./mcpjungle.db.

Opcionalmente, puedes establecer una ruta de archivo personalizada para el archivo SQLite DB:

mcpjungle start --sqlite-db-path ./.mcpjungle.db

# or
export SQLITE_DB_PATH=/path/to/.mcpjungle.db
mcpjungle start

NOTA: Eliminar ese archivo SQLite elimina todos los datos de servidores registrados y demás estado de MCPJungle almacenado en él.

Para despliegues más serios, mcpjungle también es compatible con Postgresql. Puedes proporcionar el DSN para conectarse a él:

# You can supply the database DSN as an env var
export DATABASE_URL=postgres://admin:root@localhost:5432/mcpjungle_db

#run as container
docker run ghcr.io/mcpjungle/mcpjungle:latest

# or run directly
mcpjungle start

También puedes proporcionar variables de entorno o archivos específicos de postgres si prefieres no usar el DSN:

# host is mandatory if you're using postgres-specific env vars
export POSTGRES_HOST=localhost
export POSTGRES_PORT=5432

export POSTGRES_USER=admin
export POSTGRES_USER_FILE=/path/to/user-file

export POSTGRES_PASSWORD=secret
export POSTGRES_PASSWORD_FILE=/path/to/password-file

export POSTGRES_DB=mcpjungle_db
export POSTGRES_DB_FILE=/path/to/db-file

mcpjungle start

Cliente

Una vez que el servidor está activo, puedes usar el CLI de mcpjungle para interactuar con él.

MCPJungle actualmente es compatible con servidores MCP que usan transporte stdio y HTTP transmisible.

[!NOTE] También existe soporte para SSE (server-sent events), pero actualmente no está maduro.

Veamos cómo registrarlos en mcpjungle.

Registro de servidores basados en HTTP transmisible

Digamos que ya estás ejecutando un servidor MCP http transmisible localmente en http://127.0.0.1:8000/mcp que proporciona herramientas matemáticas básicas como add, subtract, etc.

Puedes registrar este servidor MCP con MCPJungle:

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

Si usaste docker compose para ejecutar el servidor y no estás en Linux, tendrás que usar host.docker.internal en lugar de tu dirección de loopback local.

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

El registro ahora comenzará a rastrear este servidor MCP y cargará sus herramientas.

También puedes proporcionar un archivo de configuración para registrar el servidor MCP:

cat ./calculator.json
{
  "name": "calculator",
  "transport": "streamable_http",
  "description": "Provides some basic math tools",
  "url": "http://127.0.0.1:8000/mcp"
}

mcpjungle register -c ./calculator.json

Todas las herramientas proporcionadas por este servidor ahora son accesibles a través de MCPJungle:

mcpjungle list tools

# Check tool usage
mcpjungle usage calculator__multiply

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

[!NOTE] Una herramienta en MCPJungle debe ser referida por su nombre canónico que sigue el patrón <mcp-server-name>__<tool-name>. El nombre del servidor y el nombre de la herramienta están separados por un doble guion bajo __.

ej- Si registras un servidor MCP github que proporciona una herramienta llamada git_commit, puedes invocarla en MCPJungle usando el nombre github__git_commit.

Tu cliente MCP también debe usar este nombre canónico para llamar a la herramienta a través de MCPJungle.

El formato del archivo de configuración para registrar un servidor MCP basado en HTTP transmisible es:

{
  "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>"
  }
}

Registro de servidores basados en STDIO

Aquí hay un ejemplo de archivo de configuración (llamémoslo filesystem.json) para un servidor MCP que usa el transporte STDIO:

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

Puedes registrar este servidor MCP en MCPJungle proporcionando el archivo de configuración:

# Save the JSON configuration to a file (e.g., filesystem.json)
mcpjungle register -c ./filesystem.json

El formato del archivo de configuración para registrar un servidor MCP basado en STDIO es:

{
  "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"
  }
}

También puedes ver un video rápido sobre Cómo registrar un servidor MCP basado en STDIO.

[!TIP] Si tu servidor STDIO falla o arroja errores por alguna razón, revisa los registros del servidor mcpjungle para ver su salida stderr.

Variables de entorno en archivos de configuración JSON

Cuando usas un archivo de configuración JSON para registrar un servidor mcp o crear otras entidades como grupos de herramientas, el CLI puede resolver los marcadores de posición de variables de entorno en valores de cadena antes de enviar la solicitud al servidor.

• Solo se resuelven los marcadores de posición escritos como ${VAR_NAME}.
• Los marcadores de posición pueden aparecer en cualquier lugar dentro de un valor de cadena, por ejemplo prefix-${VAR_NAME}-suffix.
• La resolución ocurre en el proceso del CLI, por lo que la variable de entorno debe estar disponible donde ejecutas el comando.
• Si una variable de entorno referenciada no está establecida, el comando falla con un error.
• Esto se aplica a los campos de cadena en todo el JSON de configuración, incluidos objetos anidados y matrices de cadenas.

Ejemplo de configuración de servidor MCP:

{
  "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}"
  }
}

Ejemplo de configuración STDIO:

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

Advertencia ⚠️

Al ejecutar mcpjungle dentro de Docker, necesitas configuración adicional para ejecutar el servidor MCP filesystem.

Por defecto, mcpjungle dentro del contenedor no tiene acceso al sistema de archivos de tu host.

Por lo tanto, debes:

• montar el directorio del host al que deseas acceder como un volumen en el contenedor
• especificar la ruta de montaje como el directorio en los argumentos del comando del servidor mcp de filesystem

El docker-compose.yaml proporcionado por mcpjungle monta el directorio de trabajo actual como /host en el contenedor.

Por lo tanto, puedes usar la siguiente configuración para el servidor mcp de filesystem:

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

Entonces, el mcp tiene acceso a /host, es decir, el directorio de trabajo actual en tu máquina host.

Consulta DEVELOPMENT.md para más detalles.

Ejecutar comandos CLI desde un despliegue de Docker o Kubernetes

Si tu servidor MCPJungle se está ejecutando en un contenedor Docker remoto o en un clúster de Kubernetes, también puedes ejecutar el binario mcpjungle directamente dentro del contenedor:

docker exec -it <container_name> /mcpjungle
kubectl -n <namespace> exec -it po/<pod_name> -- /mcpjungle

[!NOTE] La imagen estándar no incluye un shell. Ejecuta /mcpjungle directamente mediante docker exec o kubectl exec.

Esto es útil para ejecutar comandos CLI desde el mismo entorno donde se está ejecutando el servidor.

Dar de baja servidores MCP

Puedes eliminar un servidor MCP de mcpjungle.

mcpjungle deregister calculator
mcpjungle deregister filesystem

Una vez eliminado, este servidor mcp y sus herramientas ya no están disponibles para ti ni para tus clientes MCP.

Configurar una URL de registro personalizada

Por defecto, el CLI se conecta al servidor mcpjungle en http://127.0.0.1:8000.

Si tu servidor se está ejecutando en un host o puerto diferente (por ejemplo, un despliegue remoto), puedes configurar la URL de registro de dos maneras:

Opción 1: Usar la bandera --registry

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

Opción 2: Configurarlo en el archivo de configuración

Crea o edita ~/.mcpjungle.conf:

registry_url: http://my-server:9000

Esto evita tener que pasar la bandera --registry en cada comando.

Problema de arranque en frío y conexiones con estado

Por defecto, MCPJungle siempre crea una nueva conexión con el servidor MCP ascendente cuando se llama a una herramienta.

Cuando la llamada a la herramienta se completa, la conexión se cierra.

Esto mantiene el sistema limpio y evita fugas de memoria.

Pero a veces esto puede causar una sobrecarga de latencia. Por ejemplo, se genera un nuevo proceso cada vez que llamas a una herramienta de un servidor mcp basado en STDIO. Si el servidor tarda varios segundos en iniciarse, esto ralentiza la llamada a la herramienta y la interacción general.

Para solucionar esto, MCPJungle también admite conexiones con estado.

Puedes establecer el session_mode a stateful (el valor predeterminado es stateless) en la configuración de tu servidor MCP:

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

mcpjungle creará una nueva conexión con este servidor mcp la primera vez que llames a una de sus herramientas.

Esta conexión no se cierra cuando la llamada a la herramienta se completa. Las llamadas posteriores a este servidor reutilizan la misma conexión, evitando la sobrecarga de arranque en frío.

La conexión solo se cierra cuando:

1. el servidor mcpjungle se detiene
2. el servidor mcp se da de baja de mcpjungle
3. la conexión expira después de un período de inactividad. Puedes establecer el número de segundos usando la variable de entorno SESSION_IDLE_TIMEOUT_SEC para configurar esto globalmente en el servidor mcpjungle (el valor predeterminado es -1, lo que significa que no hay tiempo de espera).

Cuando sea posible, se recomienda que uses conexiones sin estado (configuración predeterminada).

Integración con otros clientes MCP

Suponiendo que MCPJungle se está ejecutando en http://localhost:8080, usa las siguientes configuraciones para conectarte a él:

Claude

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

Cursor

{
  "mcpServers": {
    "mcpjungle": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

Puedes ver un video rápido sobre Cómo conectar Cursor a MCPJungle.

Copilot

Sigue la documentación de Copilot sobre configurar un servidor MCP manualmente.

Tu archivo de configuración mcp.json debería verse así después de agregar mcpjungle a él:

{
  "servers": {
    "mcpjungle": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

[!NOTE] Puede que tengas que hacer clic en Start para que Copilot realmente comience a interactuar con mcpjungle.

Habilitar/Deshabilitar herramientas

Puedes deshabilitar y volver a habilitar una herramienta específica o todas las herramientas proporcionadas por un servidor MCP.

Si una herramienta está deshabilitada, no está disponible a través del proxy MCPJungle ni de ninguno de los grupos de herramientas, por lo que ningún cliente MCP puede verla o llamarla.

También puedes deshabilitar y habilitar Prompts.

# disable the `get-library-docs` tool provided by the `context7` MCP server
mcpjungle disable tool context7__get-library-docs

# re-enable the tool
mcpjungle enable tool context7__get-library-docs

# disable all tools in context7
mcpjungle disable tool context7

# disable the whole `context7` MCP server (disables all tools & prompts)
mcpjungle disable server context7

# re-enable `context7`
mcpjungle enable server context7

# disable a prompt
mcpjungle disable prompt "huggingface_Model Details"

# disable all prompts in context7
mcpjungle disable prompt context7

Una herramienta deshabilitada sigue siendo accesible a través de la API HTTP de mcpjungle, por lo que los humanos aún pueden gestionarla desde el CLI (o cualquier otro cliente HTTP).

[!NOTE] Cuando se registra un nuevo servidor en MCPJungle, todas sus herramientas y prompts están habilitados por defecto.

Prompts

Mcpjungle admite Prompts.

Cuando registras un nuevo servidor MCP, si proporciona prompts, también se registran en mcpjungle.

Aquí hay algunos ejemplos de cómo puedes interactuar con Prompts usando el CLI:

# list all prompts provided by the huggingface mcp
$ mcpjungle list prompts --server huggingface

# Retrieve the "Model Details" prompt, supply custom arguments
$ mcpjungle get prompt "huggingface__Model Details" --arg model_id="openai/gpt-oss-120b"

Grupos de herramientas

A medida que agregas más servidores MCP a MCPJungle, el número de herramientas disponibles a través de la puerta de enlace puede crecer significativamente.

Si tu cliente MCP está expuesto a cientos de herramientas a través del MCP de la puerta de enlace, su rendimiento puede degradarse.

MCPJungle te permite exponer solo un subconjunto de todas las herramientas disponibles a tus clientes MCP usando Grupos de herramientas.

Puedes crear un nuevo grupo e incluir solo herramientas específicas que desees exponer.

Una vez que se crea un grupo, mcpjungle devuelve un endpoint único para él.

Luego puedes configurar tu cliente MCP para usar este endpoint específico del grupo en lugar del endpoint principal de la puerta de enlace.

Crear un grupo de herramientas

Puedes crear un nuevo grupo de herramientas proporcionando un archivo de configuración JSON al comando create group.

Debes especificar un name único para el grupo y definir qué herramientas incluir usando uno o más de los siguientes campos:

• included_tools: Lista nombres de herramientas específicos para incluir (por ejemplo, ["filesystem__read_file", "time__get_current_time"])
• included_servers: Incluye TODAS las herramientas de servidores MCP específicos (por ejemplo, ["time", "deepwiki"])
• excluded_tools: Excluye herramientas específicas (útil al incluir servidores completos)

Ejemplo 1: Seleccionar herramientas específicas

Aquí hay un ejemplo de un archivo de configuración de grupo de herramientas (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"
  ]
}

Este grupo expone solo 3 herramientas seleccionadas manualmente en lugar de todas las herramientas disponibles.

Ejemplo 2: Incluir servidores completos con exclusiones

También puedes incluir todas las herramientas de servidores específicos y opcionalmente excluir algunas:

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

Esto incluye TODAS las herramientas de los servidores time y deepwiki excepto time__convert_time.

Ejemplo 3: Combinar enfoques

Puedes combinar los tres campos para obtener la máxima flexibilidad:

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

Esto incluye filesystem__read_file más todas las herramientas del servidor time excepto time__convert_time.

Puedes crear este grupo en mcpjungle:

$ mcpjungle create group -c ./claude-tools-group.json

Tool Group claude-tools created successfully
It is now accessible at the following streamable http endpoint:

    http://127.0.0.1:8080/v0/groups/claude-tools/mcp

Luego puedes configurar Claude (o cualquier otro cliente MCP) para usar este endpoint específico del grupo para acceder al servidor MCP.

El cliente entonces SOLO verá y podrá usar estas 3 herramientas y no estará al tanto de ninguna otra herramienta registrada en MCPJungle.

[!TIP] Puedes ejecutar mcpjungle list tools para ver todas las herramientas disponibles y elegir las que deseas incluir en tu grupo.

También puedes ver un Video sobre el uso de Grupos de herramientas.

[!NOTE] La exclusión siempre se aplica al final. Entonces, si agregas una herramienta a included_tools y también la listas en excluded_tools, será excluida del grupo final.

Limitación 🚧

Prompts actualmente no son compatibles en los Grupos de herramientas. Estamos trabajando para solucionar este problema 🛠️

Gestionar grupos de herramientas

Actualmente puedes realizar operaciones como listar todos los grupos, ver detalles de un grupo específico y eliminar un grupo.

# list all tool groups
mcpjungle list groups

# view details of a specific group
mcpjungle get group claude-tools

# delete a group
mcpjungle delete group claude-tools

Trabajar con herramientas en grupos

Puedes listar e invocar herramientas dentro de grupos específicos usando la bandera --group:

# list tools in a specific group
mcpjungle list tools --group claude-tools

# invoke a tool from a specific group context
mcpjungle invoke filesystem__read_file --group claude-tools --input '{"path": "README.md"}'

Estos comandos proporcionan operaciones con alcance de grupo, lo que facilita trabajar con herramientas en contextos específicos y validar que las herramientas estén disponibles en tus grupos.

[!NOTE] Si una herramienta está incluida en un grupo pero luego se deshabilita globalmente o se elimina, no estará disponible a través del endpoint MCP del grupo.

Pero si la herramienta se vuelve a habilitar o se agrega nuevamente más tarde, automáticamente volverá a estar disponible en el grupo.

Limitaciones 🚧

1. Actualmente, no puedes actualizar un grupo de herramientas existente. Debes eliminar el grupo y crear uno nuevo con el archivo de configuración modificado.
2. En el modo enterprise, actualmente solo un administrador puede crear un Grupo de herramientas. Estamos trabajando para permitir que los usuarios estándar también creen sus propios grupos.

Autenticación

MCPJungle actualmente admite autenticación si tu servidor MCP HTTP Streamable acepta tokens estáticos para la autenticación.

Esto es útil cuando se usan servidores MCP proporcionados por SaaS como HuggingFace, Stripe, etc., que requieren tu token de API para la autenticación.

Puedes proporcionar tu token al registrar el servidor MCP:

# If you specify the `--bearer-token` flag, MCPJungle will add the `Authorization: Bearer <token>` header to all requests made to this MCP server.
mcpjungle register --name huggingface --description "HuggingFace MCP Server" --url https://huggingface.co/mcp --bearer-token <your-hf-api-token>

O desde tu archivo de configuración

{
  "name": "huggingface",
  "transport": "streamable_http",
  "url": "https://huggingface.co/mcp",
  "description": "hugging face mcp server",
  "bearer_token": "<your-hf-api-token>"
}

Si necesitas proporcionar un valor personalizado para el encabezado Authorization o agregar encabezados personalizados adicionales, puedes usar el campo headers en el archivo de configuración:

{
  "name": "sourcegraph",
  "transport": "streamable_http",
  "url": "https://sourcegraph.mycompany.com/.api/mcp",
  "headers": {
    "Authorization": "token <your-sourcegraph-token>",
    "Custom-Header": "custom-value"
  }
}

¡El soporte para el flujo OAuth llegará pronto!

Características empresariales 🔒

Si estás ejecutando MCPJungle en tu organización, recomendamos ejecutar el servidor en el modo enterprise:

# enable enterprise features by running in enterprise mode
mcpjungle start --enterprise

# you can also specify the server mode as environment variable (valid values are `development` and `enterprise`)
export SERVER_MODE=enterprise
mcpjungle start

# Or use the enterprise-mode docker compose file as described above
docker compose -f docker-compose.prod.yaml up -d

Por defecto, el servidor mcpjungle se ejecuta en modo development, que es ideal para individuos que lo ejecutan localmente.

En el modo empresarial, el servidor aplica políticas de seguridad más estrictas y proporcionará características adicionales como autenticación, ACL, observabilidad y más.

Después de iniciar el servidor en modo empresarial, debes inicializarlo ejecutando el siguiente comando en tu máquina cliente:

mcpjungle init-server

Esto creará un usuario administrador en el servidor y almacenará su token de acceso a la API en tu directorio de inicio (~/.mcpjungle.conf).

Luego puedes usar el CLI de mcpjungle para realizar solicitudes autenticadas al servidor.

Control de acceso

En el modo development, todos los clientes MCP tienen acceso completo a todos los servidores MCP registrados en el proxy MCPJungle.

El modo enterprise te permite controlar qué clientes MCP pueden acceder a qué servidores MCP.

Supongamos que has registrado 2 servidores MCP calculator y github en MCPJungle en modo empresarial.

Por defecto, ningún cliente MCP puede acceder a estos servidores. Debes crear un cliente MCP en mcpjungle y permitirle explícitamente acceder a los servidores MCP.

# Create a new MCP client for your Cursor IDE to use. It can access the calculator and github MCP servers
mcpjungle create mcp-client cursor-local --allow "calculator, github"

MCP client 'cursor-local' created successfully!
Servers accessible: calculator,github

Access token: 1YHf2LwE1LXtp5lW_vM-gmdYHlPHdqwnILitBhXE4Aw
Send this token in the `Authorization: Bearer {token}` HTTP header.

Mcpjungle crea un token de acceso para tu cliente. Configura tu cliente o agente para enviar este token en el encabezado Authorization al realizar solicitudes al proxy de mcpjungle.

[!TIP] También puedes proporcionar un token de acceso personalizado para tus clientes mcp y cuentas de usuario usando la bandera --access-token. Esto es útil cuando deseas gestionar los tokens tú mismo, quizás a través de un servidor de identidad central.

Por ejemplo, puedes agregar la siguiente configuración en Cursor para conectarte a MCPJungle:

{
  "mcpServers": {
    "mcpjungle": {
      "url": "http://localhost:8080/mcp",
      "headers": {
        "Authorization": "Bearer 1YHf2LwE1LXtp5lW_vM-gmdYHlPHdqwnILitBhXE4Aw"
      }
    }
  }
}

Un cliente que tiene acceso a un servidor particular de esta manera puede ver y llamar a todas las herramientas proporcionadas por ese servidor.

[!NOTE] Si no especificas la bandera --allow, el cliente MCP no podrá acceder a ningún servidor MCP.

Crear clientes mcp desde el archivo de configuración

También puedes crear un cliente MCP proporcionando un archivo de configuración JSON:

{
	"name": "foobar",
	"allowed_servers": ["deepwiki", "time"],
	"access_token": "my_secret_token_123",
    "access_token_ref": {
        "file": "/path/to/token-file.txt",
        "env": "ENV_VAR_NAME"
    }
}

Al crear un cliente desde un archivo de configuración, debes proporcionar un token de acceso personalizado porque mcpjungle no puede imprimir el token generado en la consola.

Proporcionar tokens de acceso personalizados en archivos de configuración

Hay 3 formas de proporcionar el token de acceso desde el archivo de configuración:

1. Directamente en el campo access_token: Usa esto solo con fines de prueba. No se recomienda para producción, especialmente si estás comprometiendo el archivo de configuración en el control de versiones.
2. Desde un archivo usando el campo access_token_ref.file: El archivo debe contener solo la cadena del token.
3. Desde una variable de entorno usando el campo access_token_ref.env: La variable de entorno debe contener la cadena del token.

También puedes usar marcadores de posición ${VAR_NAME} en otros lugares del mismo archivo de configuración JSON. Por ejemplo:

{
  "name": "${MCP_CLIENT_NAME}",
  "allowed_servers": ["${PRIMARY_SERVER}", "time"],
  "access_token_ref": {
    "env": "CLIENT_TOKEN_ENV_NAME"
  }
}

Creación de cuentas de usuario

Además de los clientes MCP, también puedes crear cuentas de Usuario en mcpjungle para usuarios humanos.

Un usuario tiene un conjunto de privilegios muy limitado en comparación con un administrador en el modo empresarial. Por ejemplo, pueden ver y usar servidores MCP, pero no tienen permisos de escritura en mcpjungle.

# Auto-generates a secret for user
mcpjungle create user bob
# Specify a custom access token for user
mcpjungle create user alice --access-token alice_token_123
# Create user from config file
mcpjungle create user --conf /path/to/user-config.json

El formato de archivo de configuración para crear un usuario es similar al de un cliente MCP:

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

Nuevamente, al usar el archivo de configuración, debes proporcionar un token de acceso personalizado.

Al igual que otros archivos de configuración JSON en MCPJungle, los archivos de configuración de usuario también admiten placeholders ${VAR_NAME} en campos de cadena.

OpenTelemetry

MCPJungle admite métricas de OpenTelemetry compatibles con Prometheus para la observabilidad.

• En el modo enterprise, OpenTelemetry está habilitado por defecto.
• En el modo development, la telemetría está deshabilitada por defecto. Puedes habilitarla estableciendo la variable de entorno OTEL_ENABLED a true antes de iniciar el servidor:

# enable OpenTelemetry metrics
export OTEL_ENABLED=true

# optionally, set additional attributes to be added to all metrics
export OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=enterprise

# start the server
mcpjungle start

Una vez que el servidor mcpjungle está iniciado, las métricas están disponibles en el endpoint /metrics.

Limitaciones actuales 🚧

¡No somos perfectos todavía, pero estamos trabajando duro para lograrlo!

1. MCPJungle aún no soporta el flujo OAuth para autenticación

Esto es un trabajo en progreso.

Estamos recopilando más comentarios sobre cómo la gente usa OAuth con servidores MCP, así que no dudes en iniciar una Discusión o abrir un issue para compartir tu caso de uso.

Contribuyendo 💻

¡Damos la bienvenida a las contribuciones de la comunidad!

• Para pautas y estándares de contribución, consulta CONTRIBUTION.md
• Para configuración de desarrollo y detalles técnicos, consulta DEVELOPMENT.md

Únete a nuestra comunidad de Discord para conectarte con otros contribuyentes y mantenedores.