Preface

When writing papers, submission manuscripts, or technical reports, many people use Overleaf for collaboration: editing main.tex in a browser, with compilation results hosted in the cloud. After switching to an agent runtime like DeepSeek Harness (dsh), the problem is reversed — the model can only see the local workspace by default, cannot access files in Overleaf projects, and cannot edit a section by chapter and push changes back.

DeepSeek Harness is designed with “everything is a plugin”: models, tools, sessions, and UIs can all be attached to the Cordis kernel for combination. Someone in the community has already connected this to Overleaf: the plugin is named dsh-overleaf, maintained by fly233338, and categorized under “Development and Runtime”. It does not implement its own Overleaf API, but uses the existing OverleafMCP (npm package @mjyoo2/overleaf-mcp) as a dependency, starts it via MCP stdio, and then hands the tools to the MCP Client provided by the dsh host.

First, we need to clarify the source. The installation commands introduced below come from the community plugin directory page, and can be cross-checked against the GitHub repository and npm package. This directory site is an independent community index, and has no official affiliation with DeepSeek / FangTian. Do not treat it as an official app store.

What is this

dsh-overleaf is a community open-source plugin under the MIT license, mainly written in JavaScript. The current repository version is 0.1.0. When listed on the directory page, the GitHub star count was 7, and the last push was on 2026-08-14.

One-sentence positioning: Use a Git token and a set of project IDs to connect multiple Overleaf projects to the current dsh process, allowing the agent to list projects, read files, view sections, and push changes back to Overleaf via Git after explicitly providing a commit message.

It solves the disconnect between “manuscripts in the cloud, agent running locally”. The directory page’s introduction focuses on browsing and reading; the repository README and source code also include write paths. The two are not contradictory: reading is the daily usage, while writing uses Overleaf’s Git integration and requires a mandatory commitMessage.

Core Capabilities

When the plugin starts, it parses dsh-overleaf.config.json, generates an internal project list for OverleafMCP, then starts a Node process to launch @mjyoo2/overleaf-mcp. The tool group name is overleaf, and the model will see calls starting with mcp__overleaf__.

Combining the repository description and OverleafMCP documentation, the currently available capabilities are roughly as follows:
1. List multiple configured Overleaf projects (list_projects).
2. List project files by extension, defaulting to .tex (list_files).
3. Read the content of a file at a specified path (read_file).
4. Parse the section structure in a LaTeX file, or retrieve a specific section by title (get_sections, get_section_content).
5. View a project status summary (status_summary).
6. Write an entire file or a specific section back to Overleaf; writing must include a commitMessage, with the underlying implementation being Git commit and push (write_file, write_section).

The plugin also inserts a convention into the system prompt: first call mcp__overleaf__list_projects, use the returned project ID as projectName for subsequent tools, do not switch projects throughout the entire task; writing must provide a clear commit message.

The repository author wrote their own usage experience in the README: it is suitable for reading through an entire LaTeX project, modifying source code based on existing errors, and unifying terminology and symbols across the full text. This is the maintainer’s own statement, not a third-party review. Additionally, the plugin itself does not compile documents; the so-called “fix compilation errors” relies on you pasting logs into the session, or the agent making static modifications based on the source code itself.

Environment Requirements

The repository README and package.json specify the runtime requirements:
- DeepSeek Harness 0.1.0-rc.5 or a compatible version. The plugin declares @deepseek-ai/dsh-mcp-client as a peerDependency, provided by the host, and does not include OverleafMCP source code in this repository.
- Node.js 22.19.0 or higher.
- An Overleaf Git integration token. Overleaf’s official documentation states: Git integration on the Cloud is a paid feature, requiring the project owner to have an appropriate subscription or be granted this capability; tokens are created in account settings, valid for one year, up to 10 per account, and can be used to access all Git projects you have permission for.

If Git integration is not available, the plugin will not be able to connect to projects even after installation.

Install This Plugin

The installation commands given on the community directory page are as follows, run them in the DeepSeek Harness terminal:

dsh plugin add github:fly233338/dsh-overleaf

The dsh CLI will parse this repository from GitHub and add it to the current configuration. For reproducible installations, fix the commit as shown on the directory page:

dsh plugin add github:fly233338/dsh-overleaf#commit

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

The repository README also provides two other paths, suitable for debugging from source or if you have the dsh CLI installed locally. Install from the DeepSeek Harness source directory:

cd /path/to/deepseek-harness
pnpm install
pnpm run build
pnpm dsh plugin --profile web add /path/to/dsh-overleaf

If the CLI is already on your PATH:

dsh plugin --profile web add dsh-overleaf
dsh web

The npm package dsh-overleaf@0.1.0 is available (published on 2026-08-14). For daily use, stick to the directory page’s github:fly233338/dsh-overleaf to avoid manually constructing the installation source.

Configure the Plugin

The plugin reads dsh-overleaf.config.json in the same directory as index.js. If the file does not exist, an empty template will be automatically generated on startup. Fill in a shared token and one project ID per line:

{
  "gitToken": "your-overleaf-git-token",
  "projectIds": [
    "project-id-a",
    "project-id-b"
  ]
}

The project ID comes from the segment after /project/ in the Overleaf address, for example https://www.overleaf.com/project/<PROJECT_ID>. The Git token is created in the Git Integration section of Overleaf’s account settings. The official documentation is available at:

https://docs.overleaf.com/integrations-and-add-ons/git-integration-and-github-synchronization/git-integration/git-integration-authentication-tokens.md

Restart dsh after modifying the configuration. The plugin only reads this file once on startup and generates the internal .dsh-overleaf.projects.json. Do not manually edit this generated file. The plugin does not read .env files, nor does it require environment variables like OVERLEAF_PROJECT_ID — tokens and project lists are configured via the JSON file above.

Do not commit the token to a public repository, or include it in packages you intend to publish. The security notes from OverleafMCP also apply: this token has read and write permissions for projects, and should be treated as a password.

Use with the Model

After the configuration takes effect, directly tell the model which project to work on. The example given in the repository is:

Please work on Overleaf project project-id-a and read its main.tex.

According to the prompt word injected by the plugin, the model should first call mcp__overleaf__list_projects, then use the selected ID as the projectName for subsequent tools. For read-only operations, you can stop at read_file or get_section_content; if you want to modify a section, use write_section and provide a commitMessage. The corresponding parameters in the OverleafMCP documentation are: filePath, sectionTitle, newContent (including the section title), and commitMessage.

Writing back does not modify the unsaved buffer in the Overleaf web editor, but rather a Git commit. The official Git integration has some inherent limitations, such as not supporting branches, Git LFS, or retaining executable permissions; renaming or moving files with annotations from Git may also lose Overleaf’s Track Changes. These limitations come from Overleaf, not added by this plugin, but it is worth knowing them before writing back.

Applicable Scenarios and Notes

It is suitable for users who have already placed their manuscripts on Overleaf and are using dsh for reading, rewriting, and terminology unification. Multiple projects can be written in the same configuration, sharing one token, and switched by a single MCP tool group.

The current version explicitly does not do the following:
1. Trigger compilation on Overleaf, nor download or review PDFs.
2. Operate the browser, and is not an RPA for the Overleaf web interface.
3. Embed OverleafMCP source code into this repository; it depends on the npm package @mjyoo2/overleaf-mcp@1.0.0 at runtime.

Before installing, you should open the repository to review index.js, package.json, and LICENSE. The plugin runs with the same permissions as the current dsh process, and can read the Git token you wrote into the configuration file. The security prompt on the community directory page is consistent with the repository README: first inspect the source code and license, and pin the commit if you need a reproducible environment.

Summary

dsh-overleaf does a very specific thing: connects Overleaf’s Git integration to DeepSeek Harness’s MCP toolchain, allowing the agent to interact with real LaTeX project files during the session, instead of snippets you manually pasted. Reading, viewing sections, and writing back with a commit message match the steps outlined in the README and the dependent OverleafMCP; compiling PDFs, reviewing views, and browser automation are outside the current scope.

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

GitHub: https://github.com/fly233338/dsh-overleaf

Underlying MCP: https://github.com/mjyoo2/overleafmcp

DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness