Preface¶

When modifying an unfamiliar repository with DeepSeek Harness, the most common practice of agents is to repeatedly read files, grep symbols, and guess the call relationships based on fragments. Once the session changes, this context is lost; when multiple agents modify the same codebase at the same time, they are more likely to clash on the same dependency. It often takes until after the fact to discover that tests in other directories break after modifying a function.

DeepSeek Harness (dsh) is currently in developer preview. The official repository positions itself as “everything is a plugin”: models, tools, skills, sessions, and sandboxes can all be replaced with plugins without modifying the Harness source code. As a result, a number of “memory” plugins for agents have emerged in the community. One category records conversation facts, and the other records code structures. memtrace-public belongs to the latter: it compiles the repository into a queryable knowledge graph, allowing agents to ask about functions, classes, call edges, and versions, instead of reading the entire source code again.

This article is collated after checking against the community directory page, the syncable-dev/memtrace-public repository README/LICENSE, and the DeepSeek Harness plugin package dsh-plugin-memtrace provided separately by the maintainer. The community plugin directory is an independent site and has no official affiliation with DeepSeek / Hyperfine; the README of dsh-plugin-memtrace also clearly states that this is a community-maintained Harness plugin, not an official DeepSeek product.

What is this¶

memtrace-public is a code structure memory project maintained by Syncable (GitHub organization syncable-dev), categorized under “Memory” in the community directory. As of August 18, 2026, both the directory page and the GitHub repository have 454 stars. The directory page was collected on 2026-08-17.

The one-sentence positioning comes from the repository README: Memtrace converts codebases into a real-time knowledge graph that AI coding agents can query in milliseconds, covering functions, classes, call edges, and versions, persisting across sessions, eliminating the need to repeatedly read files or rely on agents to discover those “invisible” dependencies on their own. The indexing process does not use LLM, and the graph is stored locally.

You need to distinguish between two repositories first:
- syncable-dev/memtrace-public: The public repository containing product documentation, skills, and multi-editor installation instructions, and is the current entry listed in the community directory.
- syncable-dev/dsh-plugin-memtrace: A plugin package specifically for DeepSeek Harness, responsible for registering Agent Skills and starting memtrace mcp via the official MCP client. The plugin package itself is licensed under MIT, with package.json version 0.1.0.

Memtrace itself is not a conversation memory engine. The repository distinguishes itself from Mem0 and Graphiti: the latter two are suitable for recording entity relationships such as “what users like”, and their graph construction uses LLM; Memtrace uses Tree-sitter to parse AST and locally determines edges such as CALLS, IMPLEMENTS, and IMPORTS. It does not replace session-level factual memory.

Do not interpret the NOASSERTION license on the directory page as open source. The LICENSE of the memtrace-public repository is the Memtrace End User License Agreement (EULA, effective 2026-04-13): it authorizes personal or internal use in binary form, and prohibits reverse engineering, redistribution, and using it for competing products. The README also specifies: the indexer and database (MemDB) are closed-source; the benchmark suite under benchmarks/ is released under MIT. The product is currently in private beta, and the full binary requires applying for access at memtrace.io first; after obtaining access, run npm install -g memtrace.

Core Features¶

Structural Graph Instead of Searching Text Again¶

In the graph, symbols are nodes (functions, classes, interfaces, types, endpoints) and relationships are edges (CALLS, IMPLEMENTS, IMPORTS, EXPORTS, CONTAINS). Retrieval is hybrid: Tantivy BM25, vector embeddings, Reciprocal Rank Fusion, followed by re-ranking. Community detection uses Louvain to partition modules. Cross-repository HTTP calls can be visualized as API topologies to see which services call which interfaces.

The repository packages these capabilities into more than 25 MCP tools, which are commonly used by agents including:

On the DeepSeek Harness side, these tools will appear under the name mcp__memtrace__*, for example mcp__memtrace__find_symbol. The plugin package README recommends that when asking “who is using this function”, the agent should use Memtrace instead of grep.

Bi-temporal: You Can Ask About Both Now and “Then”¶

Memtrace calls itself a bi-temporal structural graph: every symbol carries version history. The temporal engine provides six scoring modes corresponding to different questions:

Both the directory page and the README emphasize the same scenario: during refactoring, you can see dependencies and change times to avoid “modifying one function and breaking 14 unnoticed tests elsewhere”. When multiple agents share the same repository, they all access the same call graph, same impact scope, and same historical timeline.

Local Indexing and Language Support¶

The indexing implementation is in Rust + Tree-sitter, and source code is not sent to cloud LLMs. The promotional figures on the directory page and README are: 50,000 files can be indexed within 90 seconds. The repository also has a comparison table (same machine, same corpus, ground truth from Python ast and pyright LSP), for example 1,500 files take about 1.5 seconds, with API costs recorded as 0. These are maintainer benchmarks, not third-party reproduction results, and are not guaranteed values for your local machine.

Regarding languages, the “What it does” section of the README mentions scanning over 20 languages and frameworks; the list of programming languages with complete AST includes Rust, Go, TypeScript, JavaScript, Python, Java, C/C++, C#, Swift, Kotlin, Ruby, PHP, Dart, Scala, Perl, Lua, in addition to YAML, HCL/Terraform, JSON, TOML, SQL (including PostgreSQL RLS). Framework-aware scanning covers Express / NestJS / FastAPI / Django / Gin / Vapor / Lapis / Kong, GitHub Actions, Terraform, Helm, etc. Examples given on the directory page are Vapor, Lapis, Kong, GitHub Actions, Terraform, and RLS policies.

The directory page marks “main languages” as Python, which refers to GitHub’s language statistics for the memtrace-public repository, specifically the proportion of scripts and skill files in the public repository, not the implementation language of the indexer.

LeanCTX: Minimize Source Code Bytes in Context¶

Since v0.3.57, LeanCTX Native has been provided. get_source_window adds four compression modes: raw (default, original text), lightweight (fold whitespace), aggressive (remove comments and some imports), map (only keep signatures and class headers). There is also get_directory_tree to get the directory mapping in one go, with a default volume limit. The server will record a token savings ledger for the dashboard, instead of stuffing metadata into every tool response.

The optional adaptive mode selector is disabled by default, and can be enabled with an environment variable:

export MEMTRACE_ADAPTIVE_MODES=1

The repository documentation states: in internal benchmarks, it provides an additional ~14% compression compared to static language tables (docs/leanctx-native.md records +14.29%, and starts using bandit only after seeing at least 50 samples per slot). These are maintainer internal figures, and should be understood as an opt-in preview feature.

Skills for DeepSeek Harness¶

The skills/ directory of dsh-plugin-memtrace currently has 27 skills (consistent with the plugin README). The main memtrace-public README still writes “17 agent skills”, which is the product description for multi-editors, and the quantity shall prevail based on the Harness plugin package directory.

Common entry points:

Installation and Activation¶

First install DeepSeek Harness. dsh comes from @deepseek-ai/dsh, not a command built into Memtrace:

npm install -g @deepseek-ai/dsh

You can also use npx -y @deepseek-ai/dsh directly. The current startup method for the official repository is npx @deepseek-ai/dsh web, and the Web UI defaults to http://127.0.0.1:3080. Harness is still in developer preview, and the documentation notes that there will be breaking changes.

Installation Command on the Community Directory¶

The original text on the directory page is the following command, to be run in the DeepSeek Harness terminal:

dsh plugin add github:syncable-dev/memtrace-public

For reproducible installations, the directory page specifies a fixed commit:

dsh plugin add github:syncable-dev/memtrace-public#commit

Replace commit with the actual hash. The directory page also reminds users: the plugin runs with the permissions of the current dsh process, may execute code during installation, and you should inspect the source repository and license before installing.

Harness Plugin Package in Maintainer Documentation¶

Both the memtrace-public and dsh-plugin-memtrace READMEs currently point to another repository for DeepSeek Harness installation, rather than memtrace-public on the directory page:

dsh plugin --profile web add github:syncable-dev/dsh-plugin-memtrace

When not installing the global CLI:

npx -y @deepseek-ai/dsh plugin --profile web add github:syncable-dev/dsh-plugin-memtrace

Pin to main:

dsh plugin --profile web add github:syncable-dev/dsh-plugin-memtrace#main

npm channels and uninstallation are also supported:

dsh plugin --profile web add dsh-plugin-memtrace
dsh plugin --profile web remove dsh-plugin-memtrace

After installation, confirm that this entry appears in the configuration with the following command:

dsh --profile web --dump-config | grep -A4 'id: dsh-plugin-memtrace'

The existence of both commands is due to the inconsistency between the directory entry name and the maintainer’s actual plugin package, not a typo. To register skills and start the MCP in Harness, follow the instructions in the dsh-plugin-memtrace repository; the command on the directory page is the installation sentence generated for the memtrace-public entry on that site, and you should still open the corresponding repository to check if it is a Cordis plugin package before installing.

Native Binary¶

The plugin package will start memtrace mcp in the session working directory. The first run may wait for npx to download the binary, and the README says this may take about one minute. Fixing the version locally can reduce this pull:

npm install -g memtrace
export MEMTRACE_BIN=memtrace

MEMTRACE_BIN points to the local command or absolute path; if not set, it uses npx -y memtrace mcp. npm install -g memtrace requires private beta access. If you do not have access, go to memtrace.io to join the waitlist first, and do not assume that the “free installation” on the directory page means the binary is open to everyone.

Plugin compatibility is subject to the dsh-plugin-memtrace README: DeepSeek Harness 0.1.0-rc.6 and above; Node is ^22.19.0 or >=24.0.0; package.json’s engines specifies >=22.19.0, and the peer dependency is @deepseek-ai/dsh >=0.1.0-rc.1 <0.2.0-0. Platform coverage includes macOS, Linux, Windows (via npm optional dependencies providing corresponding native binaries).

The minimum recommended machine specifications for Memtrace itself are 4 cores, 8 GB RAM, and 5 GB disk; large monorepos recommend 8 cores or more, 16–32 GB. Temporal analysis requires Git, and full history yields better results. A GPU is not required.

Typical Usage¶

The following sentences come from the maintainer documentation and can be sent as-is to Harness that has the plugin installed.

1. Build the graph first, then view the architecture:

Index the current directory with Memtrace, then give me an architecture briefing.

The corresponding wording in the English README is: index the workspace, then ask for a blast radius, evolution, or architecture briefing.

2. Check the blast radius before modifying a function (original quote from the plugin’s Chinese README):

First index this repository, then give the blast radius for apply.

3. Trigger questions via skill invocation, for example:

Where is this function defined?
What will break if I change this symbol?
How did this code evolve this week?

After installing the plugin, the tool names will have the mcp__memtrace__ prefix. If the agent still uses grep, first confirm that dsh --profile web --dump-config contains dsh-plugin-memtrace and mcp-memtrace, and whether the memtrace binary can start on your local machine.

The graph data is stored in .memdb next to the project. The permission description in the plugin README is: generate memtrace mcp in the session working directory, read the repository for indexing, and do not send code to Memtrace cloud.

Applicable Scenarios and Notes¶

It is suitable for these situations:
- Maintaining large and medium-sized repositories in DeepSeek Harness, hoping that agents locate symbols based on call graphs instead of full-text search
- Checking the blast radius before refactoring, or troubleshooting “modified one place and tests elsewhere failed”
- Multiple coding agents sharing the same repository and requiring the same structural context
- Needing to view cross-service HTTP topologies instead of just the current file

It is not suitable for expecting it to “remember user preferences, meeting conclusions across sessions”, which is the work of conversation memory tools such as Mem0 / Graphiti. It is also not suitable for environments that cannot accept closed-source indexers, EULA restrictions, or private beta thresholds.

Before using, please note the following points, all from the directory page or repository documentation:
1. Permissions and Licensing. The plugin runs with the permissions of the current dsh process and may execute code during installation. memtrace-public uses a proprietary EULA, and the indexer is closed-source; the Harness plugin package dsh-plugin-memtrace uses MIT. Open and review the LICENSE files of both repositories before installing.
2. Local Index ≠ Fully Offline. Source code parsing, embedding, and graph querying are done locally. PRIVACY.md still lists several types of outbound requests: license verification, usage heartbeat (summary counts of nodes/edges, excluding repository paths and source code), first-time download of embedding models, and product telemetry enabled by default since v0.3.17 that can be turned off. To disable telemetry:

export MEMTRACE_TELEMETRY=off

3. Installation Entry Shall Prevail Based on the Plugin Package. The directory page points to github:syncable-dev/memtrace-public; the maintainer documentation points to github:syncable-dev/dsh-plugin-memtrace. When you need skills + MCP, follow the latter operation and fix the commit.
4. Harness is Still in Preview. The official repository notes that there will be compatibility-breaking changes; the plugin peer dependency is locked to the 0.1.x preview range. After upgrading dsh, you should reconfirm whether the plugin can still load.
5. Local Resources. The first indexing consumes CPU and memory, subsequent increments and queries are much lighter. If your machine is below the minimum specifications in the README, test on a small repository first, do not directly throw a 50,000-file monorepo at it.

Summary¶