Skip to main content
Glama

mcp-everything

An MCP server that turns open source repositories into tools.

Point it at a project on GitHub or GitLab and it will clone it into a Docker sandbox, build it, find the executables it produced, read their --help output, and publish one typed MCP tool per command and subcommand. The tools appear in your client's tool list while the session is running.

search_projects("fast python linter")
install_project("astral-sh/ruff")        # clone → sandbox → build → generate tools
ruff__ruff_check({ args: ["."], output_format: "json" })

Requirements

  • Node.js 20+

  • Docker (the daemon must be reachable by the user running the server)

Related MCP server: relay-mcp

Setup

No checkout is needed: npx can run the server straight from GitHub. For Claude Code:

claude mcp add mcp-everything -- npx -y github:msieurthenardier/mcp-everything

Or in any client's MCP configuration:

{
  "mcpServers": {
    "mcp-everything": {
      "command": "npx",
      "args": ["-y", "github:msieurthenardier/mcp-everything"],
      "env": { "GITHUB_TOKEN": "optional, raises the search rate limit" }
    }
  }
}

The first launch downloads and builds the server, which takes a few seconds; later launches reuse npm's cache. This form follows the default branch, so a new commit there is picked up the next time the server starts. To stay on a version you have looked at, pin a commit or tag: github:msieurthenardier/mcp-everything#<commit-or-tag>.

From a checkout

git clone https://github.com/msieurthenardier/mcp-everything.git
cd mcp-everything
npm install        # also builds dist/
claude mcp add mcp-everything -- node "$PWD/dist/index.js"

Built-in tools

Tool

What it does

search_projects

Search GitHub and GitLab; returns ids, stars, language, license.

install_project

Clone, build and generate tools for a repository.

list_projects / project_info

What is installed, its status, warnings, and its published tools.

find_project_tools

Search every generated tool, published or not, by keyword.

select_project_tools

Choose which of a project's tools are published in the tool list.

call_project_tool

Call a generated tool by name, for clients that do not refresh their tool list.

sandbox_exec

Run a shell command in a project's sandbox.

sandbox_read_file / sandbox_write_file

Move text in and out of a sandbox.

set_project_network

Turn a sandbox's outbound network on or off.

discover_tools

Regenerate tools, optionally for executables you built by hand.

connect_mcp_server / disconnect_mcp_server

Proxy an MCP server that runs inside a project's sandbox.

uninstall_project

Delete a project's container, volume and tools.

Repositories can be given as owner/name (GitHub), github:owner/name, gitlab:group/sub/name, or an https:// URL. ref pins a branch, tag or commit.

How installation works

  1. Clone. A throwaway container clones the repository (shallow) into a fresh Docker volume and reports the root listing and manifest files.

  2. Detect. The manifests decide the build system, and the runtime version the project asks for decides the image (see below).

  3. Build. A long-lived sandbox container runs a fixed recipe for that build system, with network access so dependencies can be downloaded.

  4. Go offline. The sandbox is disconnected from the network unless you passed network: true.

  5. Discover. Executables the build produced are collected: console scripts of the installed Python distribution, bin entries of package.json (including workspace packages), Cargo and Go binaries, gem executables, and anything installed to /opt/mcpe/bin. Names that resolve to the same file and print the same help are folded into one command with aliases.

  6. Proxy. Commands that turn out to be MCP servers are connected to (see below).

  7. Generate. Each executable is run with --help (the top-level command also with -h and help), and so is each subcommand it lists, two levels deep. Options become typed properties, value choices become enums, and every tool also accepts args, stdin, cwd and timeout_seconds.

  8. Publish. A subset of the generated tools is advertised in the MCP tool list; the rest stay searchable and callable (see below).

Detected by

Built with

Image

Cargo.toml

cargo build --release

rust:1

go.mod

go install of each main package (falls back to make)

golang:1

pyproject.toml, setup.py, setup.cfg, requirements.txt

pip install . into a virtualenv

python:3.13

package.json

npm / pnpm / yarn install, then the build script

node:lts

Gemfile, *.gemspec

bundle install, gem build + gem install

ruby:3

CMakeLists.txt

configure, build, install to /opt/mcpe

buildpack-deps:stable

configure, configure.ac

./configure && make && make install

buildpack-deps:stable

Makefile

make, then make install

buildpack-deps:stable

none of the above

nothing (clone only)

buildpack-deps:stable

Besides command tools, a project gets helpers where they apply: <slug>__python (run code in the project's virtualenv), <slug>__node (run JavaScript in the checkout), <slug>__npm_run (package scripts) and <slug>__make (Makefile targets).

Inside a sandbox the checkout is /workspace/repo and /workspace/work is scratch space, which is the default working directory of generated tools.

Choosing the runtime version

The image tag follows what the repository declares, in this order:

  1. An exact pin: .nvmrc, .node-version, volta in package.json, .python-version, .ruby-version, the ruby line of a Gemfile, or .tool-versions. A pin of Node 24.22.1 selects node:24.

  2. A declared range: engines.node, or requires-python (also read from Poetry, setup.cfg and setup.py). For Node the newest supported release line inside the range is used; for Python the default line if the range allows it, otherwise the nearest one that does.

  3. The default image from the table above.

A pin wins over a range because a range is a claim and a pin is what the project's own CI runs. If a build chosen from a range fails, it is rebuilt once on the next version the range allows. project_info shows which rule picked the image, and install_project(image: ...) overrides all of it.

Rust and Go keep their default image and resolve versions themselves: rustup installs the toolchain named in rust-toolchain.toml, and the go command downloads the toolchain go.mod asks for.

Which tools are published

Everything generated for a project goes into its catalog, but only up to MCPE_MAX_TOOLS_PER_PROJECT tools (default 40) are advertised to the client, since every advertised tool costs context in every conversation. The budget is spent in this order:

  1. each command's top-level tool and the project helpers, which can reach everything the command can do;

  2. each proxied MCP server, but only as a whole. If a server's tools do not all fit, none are advertised: a slice of a server is rarely a usable set;

  3. subcommand tools, with what is left.

Nothing unpublished is lost:

find_project_tools(query: "open binary")          # search the whole catalog
call_project_tool(tool: "rea__open_binary", arguments: { path: "/bin/ls" })
select_project_tools(project: "rea", include: ["open_binary", "list_*"])

select_project_tools replaces the default with your own choice (patterns with *, an exclude list, and a per-project max_tools), and reset: true goes back. The choice is kept across reinstalls.

Projects that are MCP servers

If the installed project is itself an MCP server, it is started inside its sandbox and its tools are republished here under the project's prefix:

install_project("modelcontextprotocol/servers")
servers__read_graph({})                 # tool of mcp-server-memory, proxied
servers__get_sum({ a: 2, b: 40 })       # tool of mcp-server-everything, proxied

Detection is by handshake: a launch command is started in the sandbox and offered an MCP initialize over stdio. Candidates are tried in order of evidence, and a command is left alone once one of them answers:

  1. what the repository declares in server.json (the MCP registry manifest) or mcp.json / .mcp.json. Those describe the published package (npx -y pkg mcp), which is mapped onto the command built from the checkout (pkg mcp). Entries with placeholders to fill in are skipped;

  2. the bare command, when the package that provides it depends on an MCP SDK (@modelcontextprotocol/* or fastmcp on npm, mcp or fastmcp on PyPI), or when the repository's manifests or name point to MCP;

  3. an MCP mode the command's own help advertises (--mcp, mcp, --stdio).

Launches that do not answer are reported in a warning. A command that is an MCP server only when given an argument keeps its command line tools too.

Servers that need arguments, environment variables or a different entry point are registered by hand:

connect_mcp_server(project: "servers",
                   command: ["mcp-server-filesystem", "/workspace/work"])
connect_mcp_server(project: "some-api-server",
                   command: ["node", "build/index.js"],
                   env: { "API_KEY": "..." })

How it behaves:

  • A server process is started on first use with docker exec -i, shared by later calls, stopped after MCPE_MCP_IDLE_TIMEOUT seconds without use, and restarted on the next call. It is also stopped, inside the sandbox, when a call exceeds MCPE_TOOL_TIMEOUT.

  • The sandbox's network policy applies: a server that calls an external API needs set_project_network(project, true).

  • Only tools are proxied, over stdio. Upstream resources, prompts, sampling and HTTP transports are not.

  • Arguments are forwarded as given and validated by the upstream server. Of its results, text, images and audio are passed on; embedded text resources become text; everything else is dropped.

  • A server's tools are published together or not at all (see "Which tools are published"); either way they are all callable.

When the automatic build is not enough

Many projects need a system package, a code generation step, or a build system this server has no recipe for. The install then ends as failed, or as ready with a warning that no executables were found, and the sandbox is kept. The agent can finish the job itself:

set_project_network(project, true)
sandbox_exec(project, "apt-get update && apt-get install -y python3-yaml && make")
set_project_network(project, false)
discover_tools(project, executables: ["/workspace/repo/loccount"])

install_project also accepts ecosystem and image to override detection.

Security model

Installing a project means running its build scripts and its code. This server confines that to Docker; it does not make untrusted code safe.

What the sandbox does:

  • One container and one volume per project. No host directory, Docker socket, or credential is mounted or passed in. Forge tokens stay in the server process and are only sent to their own forge's API.

  • All capabilities are dropped except the six needed to run package managers as root inside the container (CHOWN, DAC_OVERRIDE, FOWNER, FSETID, SETUID, SETGID); no-new-privileges is set; memory, CPU and process counts are limited.

  • Outbound network is removed after the build, and stays off until set_project_network turns it on.

  • Commands are passed as argument vectors, never assembled into shell strings, and are killed inside the container when they time out.

  • Only https clone URLs on allow-listed hosts are accepted.

What it does not do:

  • The build has network access, on Docker's default bridge. Code running then (and whenever you enable the network) can reach the internet and services on your host and local network.

  • Container isolation is not a security boundary against a determined attacker. A kernel or runtime escape reaches your host. For stronger isolation set MCPE_DOCKER_RUNTIME=runsc (gVisor) or run the Docker daemon in a VM.

  • Disk usage is not limited. A build can fill the Docker data directory.

  • Tool output and tool descriptions come from the project. Descriptions are length-capped, flattened to one line and prefixed with [sandboxed <repo>], but a malicious project can still put misleading text in front of the model. Review what you install, and keep approval prompts on for generated tools.

  • Proxied MCP servers describe themselves. Their tool descriptions are bounded and labelled like generated ones, but their argument schemas are passed through as the server wrote them, including any text inside.

  • Server environment values are stored in plain text in the registry file (registry.json, readable only by you) so the server can be restarted. They are handed to Docker through a private temporary file, not the command line, and are never echoed back by any tool. disconnect_mcp_server or uninstall_project removes them.

  • License is reported, not enforced. The license found in the repository is shown at install time with a warning when none is found; the server does not verify that a repository is open source.

Configuration

Environment variables, all optional:

Variable

Default

Meaning

GITHUB_TOKEN / GH_TOKEN

none

GitHub API token (search rate limit: 10/min anonymous).

GITLAB_TOKEN

none

GitLab API token.

MCPE_EXTRA_HOSTS

none

More forges to allow, e.g. gitlab.gnome.org=gitlab,git.example.com=gitlab.

MCPE_DATA_DIR

~/.local/share/mcp-everything

Where the project registry is stored.

MCPE_MEMORY / MCPE_CPUS / MCPE_PIDS_LIMIT

4g / 2 / 1024

Per-sandbox limits.

MCPE_DOCKER_RUNTIME

Docker's default

Container runtime, e.g. runsc.

MCPE_INSTALL_TIMEOUT

900

Build time limit, seconds.

MCPE_TOOL_TIMEOUT

120

Default time limit of a tool call, seconds.

MCPE_MAX_TOOLS_PER_PROJECT

40

Cap on tools published per project (the catalog is not capped).

MCPE_MCP_STARTUP_TIMEOUT

30

Seconds a proxied MCP server may take to answer the handshake.

MCPE_MCP_IDLE_TIMEOUT

600

Seconds of inactivity before a proxied MCP server is stopped.

MCPE_MAX_OUTPUT_BYTES

100000

Cap on captured stdout and stderr, each.

MCPE_IMAGE, MCPE_IMAGE_<ECOSYSTEM>

see table

Override sandbox images. Images need sh, git and coreutils timeout.

MCPE_NAME_PREFIX

mcpe-

Prefix of container and volume names.

Limitations

  • Tool generation is heuristic. It reads conventional --help output; a program that documents itself differently gets a single pass-through tool that takes args. Positional arguments are never modelled, only described by the usage line in the tool description.

  • Every installed project adds its published tool schemas to your client's context. Uninstall what you are not using, narrow it with select_project_tools, or lower MCPE_MAX_TOOLS_PER_PROJECT.

  • Version detection reads the repository root only, and trusts it. A project that declares nothing gets the default image; one whose declarations are wrong may need install_project(image: ...).

  • Subcommand tools are generated for at most 25 subcommands per command and two levels of nesting. The rest are reachable through the command's top-level tool.

  • Only the repository root is built. Monorepos with several independent projects, Java, .NET, PHP and other ecosystems without a recipe need the manual path above.

  • GUI programs, daemons and anything interactive are out of scope: tools run to completion and return their output.

  • Files go in and out as text through sandbox_write_file and sandbox_read_file; there is no host file mount.

  • Each installed project keeps an idle container running. After a reboot containers are restarted on first use.

Development

npm test              # unit and protocol tests, no Docker needed
npm run test:docker   # end-to-end against real Docker and github.com
npm run typecheck

Layout:

src/forge/      repository reference parsing, GitHub/GitLab search
src/sandbox/    Docker wrapper: probe, container lifecycle, exec, network
src/install/    build system and runtime version detection, recipes, orchestration
src/toolgen/    --help parser, help crawler, tool naming and publication,
                argv construction, MCP launch detection
src/proxy/      client sessions to MCP servers running inside sandboxes
src/registry.ts persistent project registry (shared between sessions)
src/server.ts   MCP server: built-in tools and dispatch to generated tools

License

MIT

Available Tools

15 tools
call_project_toolA

Invoke any generated project tool by name, including ones that are not published in the tool list (find them with find_project_tools). Also useful when the client's tool list has not picked up newly generated tools.

Inputs: tool (required), arguments.

connect_mcp_serverA

Start an MCP server that lives inside a project's sandbox (stdio transport) and publish its tools as "__". Use it when the project is an MCP server that was not detected automatically or needs arguments or environment variables. Registering the same name again replaces the earlier registration. Environment values are stored unencrypted in the local registry file.

Inputs: command (required), project (required), cwd, env, +1 more.

disconnect_mcp_serverA

Stop and forget an MCP server registered with connect_mcp_server, including its stored environment, and remove its tools.

Inputs: name (required), project (required).

discover_toolsA

Regenerate a project's toolset from what is currently installed in its sandbox. Pass executables (names on PATH or absolute sandbox paths) that you built or installed by hand to have tools generated for them.

Inputs: project (required), executables.

find_project_toolsA
Read-only

Search every tool generated for the installed projects, published or not, by keywords in its name and description. Returns matching tool names with their arguments; run them with call_project_tool. Use this for projects that offer more tools than fit in the tool list.

Inputs: limit, query, schema, project.

install_projectA

Clone a GitHub/GitLab repository into a fresh Docker sandbox, build it, discover its executables and generate one MCP tool per command and subcommand (named "__"). Building runs the project's own install scripts inside the sandbox with network access; afterwards the sandbox is offline unless network is true. Can take minutes; if it outlives wait_seconds, poll project_info.

Inputs: repo (required), ref, image, network, +5 more.

list_projectsA
Read-only

List installed projects with their status and number of generated tools.

Inputs: no named parameters.

project_infoA
Read-only

Show one installed project: status, build warnings or errors, discovered commands, and every generated tool with its description. Also reports progress of a running install.

Inputs: project (required).

sandbox_execA

Run a shell command (sh -c) inside a project's sandbox, by default in the checkout (/workspace/repo). Use it to inspect the repository, or to build by hand when automatic installation fell short.

Inputs: command (required), project (required), cwd, stdin, +1 more.

sandbox_read_fileA
Read-only

Read a text file from a project's sandbox. Relative paths resolve against /workspace/work.

Inputs: path (required), project (required), max_bytes.

sandbox_write_fileB

Write a text file into a project's sandbox, creating parent directories. Relative paths resolve against /workspace/work.

Inputs: path (required), content (required), project (required).

search_projectsA
Read-only

Search GitHub and GitLab for open source repositories. Returns ids that install_project accepts, with stars, language and license.

Inputs: query (required), forge, limit, language.

select_project_toolsA

Choose which of a project's generated tools are published in the tool list. Patterns match a tool's generated name, its name without the project prefix, or (for proxied MCP tools) its upstream name; * is a wildcard. With include, exactly the matching tools are published. Unpublished tools stay callable through call_project_tool. Pass reset: true to return to the default policy.

Inputs: project (required), reset, exclude, include, +1 more.

set_project_networkA

Enable or disable outbound network access for a project's sandbox. Enabling lets third-party code reach the internet and the local network.

Inputs: enabled (required), project (required).

uninstall_projectA
Destructive

Remove a project: deletes its sandbox container, its volume and its generated tools.

Inputs: project (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 15 tools

    Disambiguation4/5

    Most tools target clearly distinct operations along a coherent lifecycle (search → install → inspect → invoke → configure → uninstall). The only mild overlap is among the three tool-generation paths — install_project, discover_tools, and connect_mcp_server — which a newcomer could briefly confuse, though their descriptions differentiate them well.

    Naming Consistency4/5

    The dominant pattern is verb_noun (search_projects, install_project, call_project_tool, connect_mcp_server, uninstall_project). The sandbox tools use a resource-prefix form (sandbox_exec, sandbox_read_file, sandbox_write_file) and project_info is noun-only, but all are readable and predictable within their group.

    Tool Count5/5

    15 tools sit at the top of the ideal range and each earns its place: search, install, inspect, invoke, publish/select, sandbox I/O, network, discovery, MCP server management, and removal are all distinct capabilities. Nothing feels redundant or padded.

    Completeness4/5

    The surface covers the full project lifecycle, including sandbox file I/O, network control, and MCP server registration/teardown. Minor gaps remain: there is no in-place update/reinstall (must uninstall then install), and no way to list or delete files inside a sandbox.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Dynamic MCP server for Node.js enabling runtime tool creation, management, and execution in isolated sandboxes (Docker or Node).
      8
      11 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables developers to expose any dev tool as a safe, audited MCP server with permission tiers, audit logging, and automatic argument validation.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Lets your AI find the open-source tool it needs on GitHub and install it as an MCP tool, in a sandbox, after you approve. Reads only the folders you grant; no network unless allowed.
      5
      5
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Finds MCP servers in the MCP Rating index and connects to them on demand, proxying their tools under namespaced names and notifying the client when tools change. Each server gets a short environment allowlist plus only the variables you name for it, so other API keys in your environment aren't passed on. Files aren't isolated unless you opt into Docker containers.
      13
      425 npm
      1
      MIT