mcp-everything
Allows searching GitHub repositories and installing them into a Docker sandbox, where they are cloned, built, and converted into generated MCP tools. Repositories can be referenced as owner/name, github:owner/name, or an HTTPS URL, optionally pinned to a branch, tag, or commit.
Allows searching GitLab projects and installing them into a Docker sandbox, where they are cloned, built, and converted into generated MCP tools. GitLab repositories can be referenced as gitlab:group/sub/name or an HTTPS URL, optionally pinned to a branch, tag, or commit.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-everything install astral-sh/ruff, then run ruff check . in the sandbox"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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-everythingOr 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 GitHub and GitLab; returns ids, stars, language, license. |
| Clone, build and generate tools for a repository. |
| What is installed, its status, warnings, and its published tools. |
| Search every generated tool, published or not, by keyword. |
| Choose which of a project's tools are published in the tool list. |
| Call a generated tool by name, for clients that do not refresh their tool list. |
| Run a shell command in a project's sandbox. |
| Move text in and out of a sandbox. |
| Turn a sandbox's outbound network on or off. |
| Regenerate tools, optionally for executables you built by hand. |
| Proxy an MCP server that runs inside a project's sandbox. |
| 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
Clone. A throwaway container clones the repository (shallow) into a fresh Docker volume and reports the root listing and manifest files.
Detect. The manifests decide the build system, and the runtime version the project asks for decides the image (see below).
Build. A long-lived sandbox container runs a fixed recipe for that build system, with network access so dependencies can be downloaded.
Go offline. The sandbox is disconnected from the network unless you passed
network: true.Discover. Executables the build produced are collected: console scripts of the installed Python distribution,
binentries ofpackage.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.Proxy. Commands that turn out to be MCP servers are connected to (see below).
Generate. Each executable is run with
--help(the top-level command also with-handhelp), and so is each subcommand it lists, two levels deep. Options become typed properties, value choices become enums, and every tool also acceptsargs,stdin,cwdandtimeout_seconds.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 |
|
|
|
|
|
|
|
|
|
| npm / pnpm / yarn install, then the |
|
|
|
|
| configure, build, install to |
|
|
|
|
|
|
|
none of the above | nothing (clone only) |
|
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:
An exact pin:
.nvmrc,.node-version,voltainpackage.json,.python-version,.ruby-version, therubyline of aGemfile, or.tool-versions. A pin of Node 24.22.1 selectsnode:24.A declared range:
engines.node, orrequires-python(also read from Poetry,setup.cfgandsetup.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.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:
each command's top-level tool and the project helpers, which can reach everything the command can do;
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;
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, proxiedDetection 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:
what the repository declares in
server.json(the MCP registry manifest) ormcp.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;the bare command, when the package that provides it depends on an MCP SDK (
@modelcontextprotocol/*orfastmcpon npm,mcporfastmcpon PyPI), or when the repository's manifests or name point to MCP;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 afterMCPE_MCP_IDLE_TIMEOUTseconds without use, and restarted on the next call. It is also stopped, inside the sandbox, when a call exceedsMCPE_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-privilegesis set; memory, CPU and process counts are limited.Outbound network is removed after the build, and stays off until
set_project_networkturns it on.Commands are passed as argument vectors, never assembled into shell strings, and are killed inside the container when they time out.
Only
httpsclone 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_serveroruninstall_projectremoves 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 |
| none | GitHub API token (search rate limit: 10/min anonymous). |
| none | GitLab API token. |
| none | More forges to allow, e.g. |
|
| Where the project registry is stored. |
|
| Per-sandbox limits. |
| Docker's default | Container runtime, e.g. |
|
| Build time limit, seconds. |
|
| Default time limit of a tool call, seconds. |
|
| Cap on tools published per project (the catalog is not capped). |
|
| Seconds a proxied MCP server may take to answer the handshake. |
|
| Seconds of inactivity before a proxied MCP server is stopped. |
|
| Cap on captured stdout and stderr, each. |
| see table | Override sandbox images. Images need |
|
| Prefix of container and volume names. |
Limitations
Tool generation is heuristic. It reads conventional
--helpoutput; a program that documents itself differently gets a single pass-through tool that takesargs. 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 lowerMCPE_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_fileandsandbox_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 typecheckLayout:
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 toolsLicense
Available Tools
15 toolscall_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_toolsARead-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_projectsARead-only
List installed projects with their status and number of generated tools.
Inputs: no named parameters.
project_infoARead-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_fileARead-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_projectsARead-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_projectADestructive
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
Scored across 15 tools
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.
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.
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.
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
Create, deploy, and operate MCP servers directly from your GitHub repositories.
A MCP server built for developers enabling Git based project management with project and personal…
Secure Linux sandboxes for AI agents, as MCP tools.
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
Related MCP Servers
- AlicenseBqualityDmaintenanceDynamic MCP server for Node.js enabling runtime tool creation, management, and execution in isolated sandboxes (Docker or Node).811 npm1MIT
- AlicenseNot gradedqualityCmaintenanceEnables developers to expose any dev tool as a safe, audited MCP server with permission tiers, audit logging, and automatic argument validation.MIT
- AlicenseAqualityBmaintenanceLets 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.55MIT
- AlicenseAqualityBmaintenanceFinds 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.13425 npm1MIT