# MoLing: a dependency-free MCP server for file, shell and browser tasks

> MoLing is a Go MCP server that gives an LLM client file system access, a command-line terminal and Chrome control from a single binary. It installs without Node.js, Python or Docker, but the README admits it has only been tested on macOS.

**gojue/moling** — MoLing is a computer-use and browser-use based MCP server. It is a locally deployed, dependency-free office AI assistant.

- Repository: https://github.com/gojue/moling
- Website: https://gojue.cc
- Stars: 337 · Forks: 40
- Language: Go
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/gojue-moling

## The gap MoLing fills for local office automation

Most MCP servers that touch a desktop arrive as a Node or Python package, which means the user maintains a runtime before the assistant does anything useful. MoLing takes the opposite route. It is a single Go binary that implements system interaction through operating system APIs, so file operations and command execution do not depend on an interpreter being present. The README frames this as the main advantage: no dependency installation, and no environment conflicts involving Node.js, Python or Docker.

The audience is narrow and specific. You need an MCP-capable client such as Claude, Cline or Cherry Studio, and you want that client to read, write, merge, count and aggregate files, run system commands, and drive a Chrome browser. That is an office automation scope, not a general agent framework. The repository's prompts/ directory and the listed future plans (personal PC data organization, document writing assistance, schedule planning) point in the same direction. If your use case is calling a remote SaaS API, this is not the tool.

## How MoLing exposes file, shell and Chrome tools to an MCP client

The architecture is a thin Go server around three capability groups. go.mod shows the two libraries that matter: github.com/mark3labs/mcp-go for the protocol layer and github.com/chromedp/chromedp for browser control, with chromedp/cdproto underneath it. Everything else is plumbing (cobra and pflag for the CLI, zerolog for logging).

MCP clients connect to the server, and the server exposes tools that map onto operating system APIs. File system operations cover reading, writing, merging, statistics and aggregation. A separate command-line terminal tool executes system commands directly. Browser control goes through Chrome DevTools Protocol via chromedp, and the README states Chrome is required, with the full path configured in the system environment variables on Windows.

The server runs in one of two modes. Stdio mode is the CLI-based interactive mode; SSE mode is described as optimized for headless or automated environments. That choice determines how your client reaches the process, and it is the first decision to make before writing any client configuration.

## Installing MoLing and connecting a first MCP client

There are three installation paths in the README. The script installer is the shortest on Linux and macOS. It downloads and runs the install script from the repository's HEAD branch.

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/gojue/moling/HEAD/install/install.sh)"
```

A Windows PowerShell equivalent exists, but the README marks it as not tested and unsure whether it works, so treat that path as unverified. The second option is downloading the archive from the releases page, extracting it, and running ./moling. The third is building from source with the Go toolchain, which the README gives as:

```bash
git clone https://github.com/gojue/moling.git
cd moling
make build
./bin/moling
```

The Makefile confirms the target: make build depends on clean and calls the gobuild function, and the output lands in ./bin/. Note that make test runs with CGO_ENABLED=1, so a source build on a machine without a C toolchain is not the same proposition as using a released binary.

After installation, the server configuration lives at ~/.moling/config/config.json. If that file is missing, the README says to create it with moling config --init. To wire up a client by hand, add a block like this to the client's MCP configuration. The README gives this exact shape for Claude, whose config path is ~/Library/Application Support/Claude/claude_desktop_config.

```json
{
  "mcpServers": {
    "MoLing": {
      "command": "/usr/local/bin/moling",
      "args": []
    }
  }
}
```

The command value must be the path to the binary you actually downloaded; the README uses /usr/local/bin/moling as its example. If you would rather not edit JSON, run moling client --install, which the README says detects the MCP client and installs the configuration automatically for clients including Cline, Claude and Roo Code.

## The command-line terminal is the risk, not the file tools

The README puts a caution block directly above the feature list: command-line operations are dangerous and should be used with caution. That is not boilerplate. A tool that executes system commands on behalf of a model has the same reach as the user account running the server, and the file tools that write, merge and aggregate have the same write scope. There is no sandboxing mechanism described in the README, and no permission model beyond whatever your MCP client applies to tool calls.

The platform warning is the second limitation, and it is stated plainly: MoLing has only been tested on macOS, and other operating systems may have issues. The README lists Windows, Linux and macOS as compatible, but compatibility claims and tested platforms are different things, and the project says which one it has. Windows users also carry an extra configuration step, since Chrome's full path must be set in the environment variables for browser control to work.

Browser control has its own dependency: Chrome must be installed. That is a real constraint for anyone expecting a fully self-contained binary. The binary is dependency-free in the runtime sense, not in the sense that it brings a browser with it.

## MoLing compared with an MCP server that wraps a scripting runtime

The natural alternative is an MCP server built on Node.js or Python, such as the reference filesystem server shipped with the MCP ecosystem. The difference is deployment, not protocol. A Node-based server needs Node installed and a package manager run before first use; MoLing's README positions the binary as the answer to exactly that friction. In exchange, you give up the ability to patch the tool logic in a scripting language you can read and edit in place. MoLing's tools live in compiled Go under pkg/, so extending them means rebuilding with the Go toolchain.

A second comparison is against general computer-use agents that drive a full desktop through screenshots and clicks. MoLing does not work that way. It calls operating system APIs for file and command work and uses Chrome DevTools Protocol for the browser, which is more deterministic than pixel-level control but limited to the operations the server exposes. The README's own future plans (data organization, document writing, scheduling) sit closer to that assistant territory, and they are listed as plans, not shipped features.

## Maintenance, upgrade cost and the Apache-2.0 licence

The last push to the default branch was on 2026-03-15, the same day v0.5.0 was released. The previous release, v0.4.0, dates from 2025-05-31, so the gap between them is roughly nine months. That rhythm matters if you plan to depend on the project: releases arrive when they arrive, and there is no documented support window or backport policy in the README.

Upgrading is cheap by design. Replace the binary and restart the server; the configuration at ~/.moling/config/config.json is separate from the executable, so a version bump does not rewrite your settings. The README does not document rollback, so keep the previous binary if you need a way back. There is no migration section, which suggests no config schema changes have been announced, but that is an absence of documentation rather than a guarantee.

MoLing is licensed under Apache License 2.0, with the LICENSE file at the repository root. That is a permissive licence with an explicit patent grant and requires preservation of notices. It says nothing about what your MCP client or your model provider does with the file contents the tools read. If you point MoLing at a directory containing regulated data, the licence is not the part that should worry you.

## Conclusion

MoLing fits engineers on macOS who want file, shell and browser tools exposed to an MCP client without installing Node.js, Python or Docker, and who accept that the command-line terminal is dangerous by the project's own caution. It is the wrong choice if you need a cross-platform guarantee, since the README states only macOS has been tested, or if you are unwilling to run an agent with direct system command execution. Before adopting it, verify that moling config --init writes your expected settings to ~/.moling/config/config.json, check that Chrome is installed and, on Windows, that its full path is set in the system environment variables, and confirm the MCP client configuration written by moling client --install points at the binary you actually downloaded.

## FAQ

### What is MoLing and what does it do?

MoLing is a computer-use and browser-use MCP server written in Go. It exposes file system operations (reading, writing, merging, statistics, aggregation), a command-line terminal for executing system commands, and browser control powered by chromedp, and the README describes it as a dependency-free local office automation assistant.

### Does MoLing require Node.js, Python or Docker?

No. The README states that MoLing requires no installation of any dependencies and can be run directly, which it presents as avoiding environment conflicts involving Node.js, Python and Docker. Browser control still requires Chrome to be installed.

### Which operating systems has MoLing been tested on?

The README says MoLing has only been tested on macOS and that other operating systems may have issues, even though Windows, Linux and macOS are all listed as compatible. On Windows, the full path to Chrome must be configured in the system environment variables.

### How do I configure MoLing for an MCP client?

Add an mcpServers entry naming MoLing with the command set to the path of the binary you downloaded, as shown in the README's Claude example. Alternatively, run moling client --install, which the README says detects the client and installs the configuration automatically for Cline, Claude, Roo Code and others.

### Where is the MoLing configuration file stored?

The README states the configuration file is generated at /Users/username/.moling/config/config.json and can be modified as needed. If the file does not exist, it can be created with moling config --init.

## Sources

- [gojue/moling on GitHub](https://github.com/gojue/moling)
- [License: Apache-2.0](https://github.com/gojue/moling/blob/master/LICENSE)
- [Project website](https://gojue.cc)
- [README](https://github.com/gojue/moling/blob/master/README.md)
- [Releases](https://github.com/gojue/moling/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gojue-moling