Preface¶

DSH (DeepSeek Harness) sessions are capable, but the official stance on where the memory is stored and how to reuse it across sessions is not unified. Common practices involve building a solution with a database yourself or manually pasting the context into every conversation; neither is cheap: the former requires operations management, and the latter relies on manual upkeep.

The plugin introduced this time, xxwjxx-1210/dsh-brain-hub, falls under the “Memory” category in the community directory (skillhub.cn), and has a low star count. Its positioning is clear: Markdown as database, Git as sync. Memory is simply a bunch of .md files on your disk; no database is introduced, nor does it rely on a dedicated cloud service. It is maintained by xxwjxx-1210, released under the MIT License, has zero runtime dependencies, dist/ is the source code, and it can be read directly.

Below, I will cover “What is in the package”, “How to install”, “How to configure”, “Daily usage”, and “Notes”.

It puts three things in one package¶

The pain point the plugin solves is: web-based DeepSeek chat can go deep, DSH can execute tasks, but the memories on both sides are disconnected, requiring the person to manually paste things back and forth. The plugin packages the memory library, card confirmation, and web notes into one package:

A brain-shaped icon will appear in the top bar of the session. Clicking it opens a four-step pipeline:

1. Open Web: Open chat.deepseek.com in the DSH sidebar.
2. Let web version distill into cards: Send the distillation rules to the web version and wait for it to output cards in the specified format.
3. Review and save one by one: Each card in the popup has “View Full / Save / Discard”.
4. Backup to cloud: commit + push; existing history will automatically be pushed.

Every step has a status line (step X/Y, current card position). Step 3 displays the generation status: how many generated in X minutes, how many skipped. Step 2 relies on sidebar browser automation; it will fail if there are issues with login or page loading. The plugin will display the failure stage, page address, and input box status together.

There is a notable design trade-off: No deduplication. You can save a card on the same topic as many times as you want. Filename conflicts will automatically add -2, -3 suffixes; neither overwriting nor silent skipping occurs. This is a reasonable default for a “Second Brain” because the existence of the index and memory_search allows you to retrieve the old copy at any time.

Installation and Activation¶

The plugin provides three installation sources; the commands below come from the original README:

# From npm (recommended)
dsh plugin --profile <profile> add dsh-brain-hub

# From GitHub
dsh plugin --profile <profile> add "github:xxwjxx-1210/dsh-brain-hub#main"

# Or from local tgz
dsh plugin --profile <profile> add file:/绝对路径/dsh-brain-hub-0.2.6.tgz

The npm installation corresponds to the recommended path in the README; the 0.2.6 in the local tgz command comes from the example filename in the README. After installation, you must completely exit DSH from the system tray and restart it—the frontend bundle is only loaded at startup, and hot reload cannot replace it. The steps to upgrade the plugin are the same.

Once installed, the configuration is written in the profile layer. Note that you should not write the configuration into node_modules/<package>/cordis.patch.yml; that file will be overwritten on the next installation:

backend: git                     # git | folder | local
memoryDir: 'D:\notes\memory'    # Memory library (git repository); default $DSH_HOME/memory
notesDir: 'D:\notes\webds'      # Web version notes; default $DSH_HOME/dsh_memory
remote: 'https://github.com/<你>/<私有仓库>.git'
branch: main                    # default main
coreLimit: 3000                 # Core memory injection limit (characters)
autoPull: true                  # pull --rebase on startup
autoPush: true                  # auto push after writing
readOnly: false                 # true means all write tools reject directly
injectProgress: true            # inject tail of progress.md into system prompt

The remote field can be left empty and it will still run, just without pushing. A purely local memory library is also usable.

Clicking the brain icon in the top bar for the first time will pop up a beginner’s guide: three usage steps plus three cloud save methods. After selecting one, it gives a YAML snippet that can be pasted directly. After clicking “Got it, start using”, it will not appear again, and the mark is written to <memoryDir>/hub.json.

Three cloud save methods, choose based on your backup attitude¶

The backend field determines how the memory library is backed up. The three schemes cover the needs of “want version history”, “don’t want to touch git”, and “content sensitive”:

# git
config:
  backend: git
  remote: 'https://github.com/<你>/<私有仓库>.git'

# OneDrive / sync drive
config:
  backend: folder
  memoryDir: 'C:\Users\<你>\OneDrive\brain-hub'

# Save only locally
config:
  backend: local

In folder mode, the fourth step of the pipeline does not execute git commit, it only prompts that the file has been saved to the sync drive.

Review cards one by one: Cloud and local separated¶

Each card in the confirmation window has two buttons:

• Save to Cloud: Writes to notes/, enters git, and will push.
• Save Local Only: Writes to private/, permanently excluded in .gitignore, and will never be pushed under any circumstances.

The criteria from the README are straightforward: Will you get nervous if a colleague or client sees this card? Real client names, quotes, contact information, and unannounced projects go to local; methodology, criteria, and anonymized cases go to the cloud.

If the web version hangs—no login, pops up “Abnormal Environment”, or the sidebar hasn’t loaded—the plugin leaves two fallback paths that don’t rely on auto-injection: You can “Copy Distillation Rules” from the menu and paste it to the web version, or “Collect Last Answer from Web” from the menu to directly read the current chat body, split into cards, and enter step 3 for confirmation. The flow can still be completed even if step 2 is completely broken.

Data format and tools for the model¶

One card is one Markdown file with frontmatter:

---
id: 20261105-120000-标题
title: "标题"
tags: 标签A, 标签B
created: 2026-11-05T12:00:00.000Z
updated: 2026-11-05T12:00:00.000Z
uploaded: true
---
# 标题

正文

The format of notes/ is compatible with dsh-memory-github and can take over old libraries directly; private/ is the same format, just not in git.

The plugin exposes nine tools to the model: memory_write, memory_search, memory_read, memory_list, memory_stats, memory_core, memory_update, memory_forget, memory_sync. When readOnly: true, write-type tools directly return rejection text and do not generate commits. RPC is used between the client and the host, POST /api/plugin-rpc/brain-hub. Envelope { type:"client-request", rpcId, method, payload:{ endpoint, payload } }. Endpoints include status, hub.settings, hub.rename, cards.list, cards.save, cards.read, cards.update, cards.discard, cards.upload, progress.save, progress.read, progress.history, memory.sync, prompt.get, prompt.save.

Who it’s for, and some notes¶

Suitable for people who: are already using DSH, are used to long conversations on the web version of DeepSeek, want to solidify the judgments, processes, and conclusions of the chat into a searchable file library, and do not plan to set up a database for this. backend: folder allows people unfamiliar with git to use it, and local covers sensitive content scenarios.

Before using, it is recommended to confirm the following points:

1. The plugin runs with the current DSH process permissions. You should check the source code and license before installing. This plugin is MIT License, dist/ is the source code, zero runtime dependencies, and the audit cost is low.
2. The project star count is low, it is a plugin maintained by an individual, and there is no guarantee of a long-term maintenance rhythm. It does not deduplicate or perform vector retrieval; search is weighted scoring based on title/tag/body; do not expect semantic search for the retrieval experience.
3. The web side relies on sidebar browser automation. You must first log in to chat.deepseek.com in the sidebar, and DSH requires re-login every time it restarts; DeepSeek may pop up “Abnormal Environment” in the embedded view, at which point step 2 will fail, and you need to use the fallback path in the menu.
4. The quality of card splitting depends on the prompt. The rules are in <memoryDir>/prompts/distill.md, editable directly in the panel, and takes effect immediately without restarting.
5. Only supports single repository, single branch. Multi-person collaboration relies on git to resolve conflicts yourself.
6. The strategy of no overwrite, no silent skip means repeated topics will leave multiple cards. Cleanup depends on manual operation via memory_forget; do not expect automatic merging.

The tool list and RPC endpoints come from the README; actual fields depend on the version of the plugin you install.

Summary¶

The value of dsh-brain-hub lies in splitting the “memory” task to the most primitive storage: Markdown files, git sync, review cards one by one, and separating cloud and local. It has no database, no vector library, and no complex sync protocol—filename conflicts add suffixes, search is weighted scoring by fields. These trade-offs bring about a memory layer that is readable, modifiable, and has a self-defined backup strategy.

Directory page: https://www.skillhub.cn/plugins/xxwjxx-1210/dsh-brain-hub
Source code and documentation: https://github.com/xxwjxx-1210/dsh-brain-hub