Preface

DeepSeek Harness (command name dsh) is an open-source agent runtime developed by DeepSeek AI. The official repository summarizes its core philosophy in one sentence: Everything is a Plugin. Models, tools, skills, sessions, sandboxes, and interfaces can all be added or removed via profiles without modifying the harness source code. The official onboarding guide suggests installing Node.js first, then running npx @deepseek-ai/dsh web. It is currently a developer preview release, and its APIs are subject to change.

When connecting external tools to agents, the Model Context Protocol (MCP) has become a common standard: one side is an MCP server running in an independent process, and the other side is a client in the host environment. The built-in bridge layer of DSH is @deepseek-ai/dsh-mcp-client: each server is defined as a Cordis plugin entry, and the discovered tools will be registered to ctx.tools in the format mcp__server_name__tool_name. The official repository’s examples/mcp-memory clearly demonstrates this: DSH is only responsible for launching stdio commands or connecting to Streamable HTTP via overlay, and will not download servers, initialize databases, select models, or manage another HTTP service on your behalf. As a result, the most time-consuming part is often not “whether you can connect to MCP”, but piecing together a YAML file from scratch and verifying which servers can still connect one by one.

The community directory DeepSeek Harness Plugin Library features dsh-mcp-bridge maintained by Edge-Echo. It packages a curated set of MCP servers into an installable bundle: it only enables zero-configuration demos by default, with the rest pre-configured in comments, and its connectivity is verified via repository scripts and CI. Please note that this directory is an independent website and has no official affiliation with DeepSeek / FunProphet, and is not an official app store. Please refer to the directory page for the exact installation commands, and cross-check the functional boundaries with the repository README, cordis.patch.yml, servers/*.json, and the official dsh-mcp-client documentation.

What is this

dsh-mcp-bridge is an all-in-one MCP plugin for DeepSeek Harness, maintained by Edge-Echo. Its source code is hosted at Edge-Echo/dsh-mcp-bridge under the MIT license, and its primary language is JavaScript. The npm package name is also dsh-mcp-bridge, with the current version 0.1.3 released on 2026-08-15. It depends on @deepseek-ai/dsh-mcp-client ^0.1.0-rc.6 and requires Node.js >=22. The directory categorizes it under the “Memory” section — the package does include a memory preset for in-session knowledge graphs — but the plugin itself is not a standalone memory engine, but a set of enableable MCP server definitions.

As of August 18, 2026, both the directory detail page and the GitHub repository show a 4-star rating. The directory added it on August 15, 2026, and the last push to the repository was on the same day. The GitHub topics include dsh-plugin, deepseek-harness, and mcp.

The problem it solves can be summarized as: no more guessing which MCP servers can run in DSH from a blank YAML file. The plugin provides machine-readable definitions for each curated server in the servers/ directory, and scripts/verify-servers.mjs runs connectivity checks one by one; the GitHub Actions workflow verify.yml runs the same script on main branch pushes and pull requests. The bridging capability comes from the DSH built-in client: supporting stdio and streamable-HTTP transports, automatic reconnection, and HMR hot replacement after patch changes.

Which MCP Servers Are Curated

The repository README and cordis.patch.yml are consistent: only the official MCP everything demo server is enabled by default, with the remaining entries written in comments and can be uncommented as needed. The responsibilities of the six entries are as follows.

  1. everything (enabled by default)
    Corresponds to @modelcontextprotocol/server-everything, a zero-configuration demo server launched via local npx without requiring an API key. It provides demo tools such as echo, addition, long-running tasks, and small image generation. The README table lists 13 tools; the verification note in servers/everything.json states that it was fully tested on Windows on August 15, 2026, and calling mcp__everything__echo with the hello parameter returns Echo: hello.

  2. memory (ready to use after uncommenting)
    Corresponds to @modelcontextprotocol/server-memory, an in-session knowledge graph server for entities, relationships, and observations, without requiring additional environment variables. The README lists 9 tools; servers/memory.json marks verify.status as verified with the same date of August 15, 2026. This is the direct reason the directory categorized it under “Memory”. It is a reference-implementation-level MCP memory server, not a standalone DSH memory plugin like graph-memory.

  3. filesystem
    Corresponds to @modelcontextprotocol/server-filesystem, which restricts read/write and search operations to explicitly authorized root directories. The final parameter must be changed to a real existing directory; the placeholder path C:/path/to/allowed/root cannot be used directly. servers/filesystem.json marks the status as needs-config; the verification note states that it can list tools when given a real directory (13 tools in the note). The README table lists 14 tools. The two numbers do not match, so please refer to the actual number of tools listed by the local verify script before enabling.

  4. github
    Performs operations on repositories, issues, and pull requests, requiring the environment variable GITHUB_TOKEN. Both cordis.patch.yml and servers/github.json remind users that the official GitHub server has been migrated to github-mcp-server, and the current preset still uses @modelcontextprotocol/server-github. Please confirm which package name is currently recommended in the ecosystem before enabling. The status is needs-config with no verification date listed.

  5. playwright
    Corresponds to @playwright/mcp, providing browser automation functions such as navigation, clicking, form filling, and screenshot taking. It will download the browser on first run, which is resource-intensive, so it is skipped in CI. You can set PLAYWRIGHT_BROWSERS_PATH or accept the first-time download.

  6. remote-http
    A template entry using transport: streamable-http for connecting to self-hosted or hosted HTTP MCP servers. The example URL is http://localhost:3000/mcp, with an optional Bearer token. The README describes it as a shared entrypoint for DSH, Reasonix, and CodeWhale: all three are agent harnesses, and MCP is their common language.

The tool names exposed to the model follow the same server-qualified format as Claude Code / Codex. For example, the echo tool from the demo server is mcp__everything__echo. The official dsh-mcp-client also notes that currently only Tools are bridged, with no consumers for Resources and Prompts in the harness.

Installation and Activation

Prerequisites: dsh and pnpm must be available in your local PATH. The repository README states that dsh plugin forwards commands to pnpm; if you do not have pnpm installed, run npm i -g pnpm first. package.json requires Node.js >=22.

The installation command provided by the community directory page, to be run in the DeepSeek Harness terminal:

dsh plugin add github:Edge-Echo/dsh-mcp-bridge

The dsh CLI will parse the plugin from GitHub and add it to the current configuration. For reproducible installations, pin the commit hash as instructed on the directory page:

dsh plugin add github:Edge-Echo/dsh-mcp-bridge#<commit>

Replace <commit> with the actual commit hash from the repository, do not keep the literal placeholder.

The repository README also provides an installation method targeting the web profile using the npm package name:

dsh plugin --profile web add dsh-mcp-bridge
# Local checkout: dsh plugin --profile web add ./dsh-mcp-bridge
dsh web        # Restart the profile

Do not mix the two entrypoints with guessed owner/repo pairs. The directory page uses github:Edge-Echo/dsh-mcp-bridge as the standard; the README uses the npm package name dsh-mcp-bridge. The plugin runs with the permissions of the current DSH process, and may execute code during installation. Please review the source code and MIT license before installing.

Typical Usage

After installation and profile restart, only everything will run by default. The first call will download the corresponding server package via npx, and subsequent calls will use the cache. The self-test method provided by the README is to ask the model to “call the echo tool of the everything server with hello”, which should use the mcp__everything__echo tool.

To enable the in-session knowledge graph, uncomment the mcp-memory section in the current profile’s cordis.patch.yml. Profile patch changes will take effect via HMR, and the documentation states that no process restart is required. The corresponding entry looks like:

- id: mcp-memory
  name: '@deepseek-ai/dsh-mcp-client'
  config:
    serverName: memory
    transport: stdio
    command: npx
    args: ['-y', '@modelcontextprotocol/server-memory']

When enabling filesystem, change the final parameter to a real root directory, do not use the placeholder path. Before enabling github, prepare your GITHUB_TOKEN and reconfirm the currently recommended package name.

To add your own stdio MCP server, it is recommended to add it to the profile’s user patch layer (also via HMR):

# $DSH_HOME/profiles/<name>/cordis.patch.yml
- id: mcp-myserver
  name: '@deepseek-ai/dsh-mcp-client'
  config:
    serverName: myserver
    transport: stdio
    command: npx
    args: ['-y', 'your-mcp-server']
    env:
      YOUR_TOKEN: !!js process.env.YOUR_TOKEN

serverName must be unique within the same process, and can only contain [A-Za-z0-9_-] characters, with a length of 1 to 32. For remote HTTP servers, change transport: streamable-http and fill in the url and optional headers.

To verify the curated servers locally, run the following commands in the repository:

npm install
npm run verify
# Equivalent to: node scripts/verify-servers.mjs

The script will print PASS / SKIP / FAIL for each server, and exit with a non-zero code if any check fails. Adjust the timeout for a single server using the VERIFY_TIMEOUT_MS environment variable; the CI uses 45000. To test a single server: node scripts/probe-server.mjs npx -y your-mcp-server.

Use Cases and Notes

This plugin is suitable for users already using DSH who want to avoid writing MCP YAML from scratch: first confirm the demo pipeline, then enable memory, filesystem, or remote HTTP via comments. It is also suitable for scenarios where you need to expose the same set of HTTP MCP servers to DSH and other harnesses. It is not intended to be used as an “official MCP app store”, nor is it recommended to fully enable GitHub tokens, local filesystem root directories, or browser automation without reviewing the source code first.

Please note the following points, all sourced from the directory page, repository documentation, or official client instructions, not inferred from outside the recommended usage checklist.

  1. Permissions and Trust. The directory page notes that the plugin runs with the permissions of the current DSH process and may execute code during installation. The filesystem server can read and write authorized root directories; the github server can access repositories and issues; the playwright server can control the local browser. Only authorize repositories you have reviewed the source code and license for, and pin commits for reproducible deployments.

  2. Default non-fatal failures. failOnStartupError defaults to false: if a server fails to connect, it will only log the error without registering tools, and the plugin entry will still activate. If the plugin appears to be installed but no corresponding mcp__… tools are visible in the model, first check the profile logs.

  3. Verification coverage. The CI runs checks for the zero-configuration setup; github, playwright, and remote-http are marked as needs-config or explicitly excluded in the catalog. The “verified” label in the README means the script has run connectivity checks against the current curated definitions, not a guarantee for every configuration on your machine. The number of filesystem tools also differs between the README and servers/filesystem.json.

  4. Capability boundaries of the official client. @deepseek-ai/dsh-mcp-client only registers MCP Tools into ctx.tools. Currently, there are no harness-side consumers for Resources and Prompts. Stdio child processes are started and stopped along with the plugin lifecycle; HTTP services must be running beforehand.

  5. Windows. The README states that the MCP SDK uses cross-spawn, which can resolve .cmd shims, so no separate npx.exe is required. If you encounter hangs when using dsh --profile "task" for headless verification, the documentation requires that the profile’s dsh.profile.bundles includes @deepseek-ai/dsh-headless; running dsh plugin add @deepseek-ai/dsh-headless will return a 404 due to unpublished dependencies, so you need to add it manually. Without this package, the plugin tree will activate, but no agent will consume tasks.

Summary

dsh-mcp-bundle bundles the official DSH MCP client and a set of curated server definitions: install the bundle with one command, enable everything by default for pipeline verification, and enable memory, filesystem, GitHub, Playwright, and remote HTTP via comments. Connectivity checks are provided via repository scripts and CI, but “being connectable” does not mean your tokens, root directories, and browser downloads are already properly configured.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-mcp-bridge/

GitHub: https://github.com/Edge-Echo/dsh-mcp-bridge