Preface¶

DeepSeek Harness (dsh) is an open-source agent runtime developed by DeepSeek, which the official repository summarizes in one sentence: Everything is a plugin. Model adapters, tools, sessions, sandboxes, and web interfaces can all be added or removed at the configuration layer without modifying the core source code. The project is currently in developer preview, and the interfaces will continue to change. Independent plugin directory sites have emerged in the community, aggregating and displaying GitHub repositories tagged with the dsh-plugin topic. Please note that these directories have no official affiliation with DeepSeek / Fang Intelligence and should not be treated as an official app store.

When using dsh web to run agents on a daily basis, many people connect external capabilities to MCP (Model Context Protocol): remote HTTP services and processes started locally via npx / uvx are common implementations. DSH’s built-in @deepseek-ai/dsh-mcp-client supports static headers, but the repository’s README clearly states two shortcomings: no OAuth support and no local stdio transport. Remote MCP services that require browser login, or starting an MCP process locally with a single command, require alternative solutions.

dsh-mcp-manager integrates this functionality into the Settings → MCP page of the web interface: add a server once, HTTP servers can use browser OAuth or static tokens from environment variables, stdio servers can directly spawn local processes, and tools are registered in the DSH convention as mcp__<server_name>__*. This article is collated after cross-verifying against the community directory details, the GitHub repository README (both Chinese and English), package.json, and the official deepseek-ai/deepseek-harness repository.

What is This¶

dsh-mcp-manager is a development and runtime plugin for the DeepSeek Harness web interface, maintained by hyqhyq3, licensed under the MIT License, and primarily written in JavaScript. The community directory categorizes it under “Development and Runtime”, with an inclusion date of 2026-08-06. The repository was created on 2026-08-13; as of 2026-08-18, GitHub shows 7 stars, while the directory page shows 6 — star counts change, so refer to the repository page for the accurate number. The version in package.json is 0.6.0.

It solves a specific problem: centrally managing MCP servers in the settings page,弥补ing the built-in client’s lack of OAuth and local stdio support. HTTP servers support authorization code + PKCE and perform dynamic client registration per RFC 7591; services without OAuth use environment variable names to reference Bearer tokens, so secrets are not written into configuration files. Stdio servers spawn child processes directly via the plugin, using JSON-RPC over stdin/stdout. Tools can either be exposed directly to the model, or an optional on-demand broker can be enabled, which wraps the model-facing calls into three fixed tools.

Core Features¶

The capabilities listed in the repository README can be divided into several sections, with only the verified parts covered below.

Settings Page Management. The client half mounts an MCP tab in the settings.section slot. Adding, in-place editing, enabling/disabling, and deleting are all done on the same page: you can modify the name, switch between stdio and HTTP, change authentication methods and headers, without deleting and recreating the server. Status badges include Connected (N tools), Pending Authentication, Authenticating, Error, and Disabled. Disabling will unregister the server’s tools and disconnect the connection, while retaining configuration and OAuth tokens; re-enabling will automatically reconnect without requiring re-login.
OAuth (Authorization Code + PKCE). The host half handles dynamic client registration and PKCE, with the callback landing on DSH GUI’s own webserver, with a path like http://127.0.0.1:<port>/mcp-manager/callback/<id>. The origin is derived from the browser’s actual address, so the GUI can be accessed via any host/port. After logging in once, the refresh_token will be rotated, and automatic reconnection will occur after restarting. Each GUI origin corresponds to one client registration; if the GUI address changes, a new registration will be created on the next login.
Static Bearer Token. For HTTP servers without OAuth, use the Codex-style tokenEnv: only write the environment variable name in the configuration (e.g. MCP_BEARER_TOKEN), so the token itself is never persisted to disk. You can also configure headers (direct values) and headerEnv (values read from environment variables), aligning with Codex’s http_headers / env_http_headers.
Stdio Local Processes. Commands can be npx, uvx, python, etc., and the plugin is responsible for spawning, reconnecting, and recycling child processes on exit. On Windows, commands are started via cmd.exe to parse shims like npx.cmd. HTTP communication uses Streamable HTTP (POST JSON-RPC, Mcp-Session-Id, SSE or JSON responses).
Tool Registration and On-Demand Broker. By default, tools from connected servers are registered with the same mcp__<server_name>__* naming convention as the built-in client, and JSON Schema cleaning supported by the registry is performed. There is an “On-Demand MCP Tool Invocation” toggle at the top of the page, which is off by default; when enabled, Native-mode agents will only see three broker tools: mcp_search_tools, mcp_describe_tool, and mcp_execute_tool. The original mcp__* tools will no longer appear in model requests, and direct calls to them will be rejected. This toggle applies to the entire profile and persists after restarting. When stdio and Streamable HTTP servers receive notifications/tools/list_changed, only newly added, removed, or schema-changed registrations are updated.
Workspace Isolation. Global servers are visible to all workspaces; workspace servers are written to <workspace>/.dsh/dshmm/mcp.json, and tools are only registered for sessions resolved to that workspace directory. After selecting a workspace, you can hide specified global servers. The serverName must be unique across all global and workspace sources, and duplicates will be marked as conflicts and skipped. Manual edits to mcp.json will be hot-reloaded; if the JSON is invalid, the interface will show an error and continue using the last valid configuration. Workspace OAuth tokens are still written to ~/.dsh/mcp-manager.json and not included in the declarative mcp.json.

The state file is ~/.dsh/mcp-manager.json: server configurations, OAuth client registration information, and tokens are stored here. Static tokens only save the environment variable names.

Installation and Activation¶

The installation command given on the community directory details page is:

dsh plugin add github:hyqhyq3/dsh-mcp-manager

The repository README provides more complete instructions, as this plugin declares dsh.client.platform as web and needs to be attached to the web profile:

npx -p @deepseek-ai/dsh dsh plugin --profile web add github:hyqhyq3/dsh-mcp-manager

After installation, restart dsh --profile web and refresh the page. The package declares dsh.bundle.patch, so the plugin will activate automatically without manual edits to cordis.patch.yml.

For reproducible installations, the directory page recommends pinning the commit hash:

dsh plugin add github:hyqhyq3/dsh-mcp-manager#<commit>

The prerequisites, verified against the README, are as follows:
- DeepSeek Harness uses the web profile (npx @deepseek-ai/dsh web)
- Node.js ^22.19 or >=24, with pnpm in the PATH
- On Windows 10/11 when running stdio servers, commands are started via cmd.exe

The directory page has a fixed reminder: the plugin runs with the permissions of the current dsh process, and may execute code during installation. You should inspect the source code repository and license before installing.

OAuth also requires that the MCP server’s authorization party allows loopback redirects. The callback is received by DSH GUI’s own webserver, rather than guessing via an open port.

Typical Usage¶

Open the Settings → MCP page in the DSH Web UI, and click ＋ Add MCP Server.

When selecting the user scope, the server will be visible to all workspaces; when selecting workspace, specify the workspace from the second dropdown, and the configuration will be written to that workspace’s .dsh/dshmm/mcp.json.

For HTTP servers, fill in the name (which determines the mcp__<name>__* prefix), URL, authentication method (OAuth or static token), and optional headers. For OAuth servers, click Authenticate after saving, the browser will open the login page, and after consenting and redirecting back, the tools will be registered immediately. For static tokens, only fill in the environment variable name, e.g. MCP_BEARER_TOKEN.

For stdio servers, fill in the name, command, line-by-line arguments, optional environment variables, and working directory. After saving, the plugin will immediately spawn the local process and connect.

When on-demand mode is off (default), a server named odin will expose tools directly to the agent, with the example given in the README:

mcp__odin__search_tools     mcp__odin__describe_tool
mcp__odin__execute_tool     mcp__odin__list_tool_scopes

When on-demand mode is enabled, the Native agent will only see three brokers:
- mcp_search_tools({ query, server?, limit? }): Defaults to a maximum of 10 lightweight results, with a hard limit of 20; the query score is calculated as +2 for server name, +3 for tool name, and +1 for description
- mcp_describe_tool({ name }): Returns the description and input schema for tools visible in the current session
- mcp_execute_tool({ name, arguments }): Executes via the DSH standard tool pipeline; it is recommended to call describe first, but it is not mandatory

Workspace configurations can also be written manually. The example mcp.json given in the README is as follows:

{
  "mcpServers": {
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "unity-mcp": {
      "type": "http",
      "url": "http://localhost:8090/",
      "authMode": "static",
      "tokenEnv": "UNITY_MCP_TOKEN"
    }
  },
  "exclude": ["github"]
}

type defaults to http; the cwd for stdio servers defaults to the workspace root. exclude lists global server names to hide in this workspace. For workspaces already registered in DSH, you can also add, edit, and delete servers directly in the UI, with the same effect as editing the file manually.

Use Cases and Notes¶

This is suitable for users who are already using dsh web and need to connect MCP to their agent loops. Good matches include: remote MCP services that require browser OAuth; starting a stdio server locally with npx / uvx / python; isolating MCP configurations per project instead of sharing a single global set across all workspaces; having a large number of MCP tools and wanting to use an on-demand broker to narrow the schema per request.

There are several boundary cases to clarify before use.

The plugin only bridges MCP tools, not resources and prompts. On-demand filtering currently only applies to DSH’s default native presentation; agents using code or both modes will retain the full MCP catalog to avoid incomplete generative SDKs or blocking Code Mode subcalls incorrectly.

OAuth tokens are stored as plain JSON in ~/.dsh/mcp-manager.json, and the README requires treating this file as confidential. Static tokens and values from headerEnv are read from environment variables and never persisted to disk. Workspace OAuth tokens are also stored in this same state file, not in mcp.json.

Stdio servers are long-lived child processes that live for the lifecycle of the plugin. On POSIX systems, args are split by spaces, and quotes can protect arguments containing spaces, but there is no shell expansion. On Windows, the entire command line is passed to cmd.exe, so &, |, >, and %VAR% will be interpreted; the repository recommends using absolute paths and quoting arguments containing spaces.

The plugin runs with the permissions of the current dsh process. Before installing community plugins, you should inspect the source code and license; for reproducible environments, pin the installation command to a specific commit. The community directory is an independent site, so refer to the directory page and the repository’s original text for installation commands, do not construct them manually based on the plugin name alone.

Summary¶

dsh-mcp-manager centralizes MCP server addition, authentication, startup/shutdown, and workspace isolation into DeepSeek Harness’s settings page,弥补ing the built-in client’s lack of OAuth (PKCE + dynamic client registration) and local stdio support. Tools are registered by default in the mcp__<name>__* convention, and you can also enable the on-demand broker so that Native mode only sees three fixed entry points. It is a community MIT-licensed project, not an official built-in feature; inspect the repository before installation, and treat the OAuth state file as confidential.

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

GitHub: https://github.com/hyqhyq3/dsh-mcp-manager

Manage MCP Servers in DeepSeek Harness Settings Page with dsh-mcp-manager