mcp-overleaf

ChatGPT MCP supported. Deploy the remote server, add its HTTPS /mcp URL in ChatGPT Plugins, then sign in with Auth0. Set it up →

Ever asked an agent to fix one line in an introduction, only for it to rewrite the project and erase the preamble?

With mcp-overleaf:

“Replace the final paragraph of Methods with this Markdown, then check the compile errors.”

It finds the section, produces the LaTeX, saves it to Overleaf, and leaves a commit when it writes through Git.

What it does today

Works with Claude Code, Claude Desktop, Cursor, and standard MCP clients out of the box. ChatGPT MCP is supported through remote Streamable HTTP with Auth0 sign-in; use it to read and write your own Overleaf projects from a ChatGPT conversation.

Every tool, with what it needs: Tools.

Related MCP server: MiLatexAI

Quick start

Requires Node.js 20+ and git. Get a Git token in Overleaf → Account Settings → Git Integration → Generate token.

Claude Code

claude mcp add overleaf -e OVERLEAF_GIT_TOKEN=olp_... -- npx -y mcp-overleaf

Claude Desktop / Cursor / others

{
  "mcpServers": {
    "overleaf": {
      "command": "npx",
      "args": ["-y", "mcp-overleaf"],
      "env": {
        "OVERLEAF_GIT_TOKEN": "olp_...",
        "OVERLEAF_PROJECT_ID": "optional default project id"
      }
    }
  }
}

Then just ask:

• "Show me the outline of my thesis."

• "Rewrite the Method section from this Markdown draft."

• "Compile and list the errors."

• "Reply to the open review comments."

On Windows, if the client cannot find npx, use "command": "cmd" and "args": ["/c", "npx", "-y", "mcp-overleaf"]. To opt in to web mode, see Credentials.

ChatGPT / Codex (remote MCP, experimental)

This mode needs a public HTTPS deployment and Auth0. Each user signs in with Auth0, then registers their own Overleaf Git token through a separate trusted settings page. Never paste an Overleaf token into a chat.

docker build -t mcp-overleaf .
docker run --rm -p 3000:3000 --env-file .env -v mcp-overleaf-data:/data mcp-overleaf

In ChatGPT, open Plugins → Add custom MCP server, enter https://<your-domain>/mcp, and select OAuth. See the remote MCP + Auth0 guide for Auth0 setup, environment variables, the credential-registration API, and production notes.

See it in action

Real responses from mcp-overleaf 0.1.0, run against a sample paper. Nothing in these screenshots was edited.

Tools

¹ web = the optional web mode, which is off by default; see Overleaf's terms and web mode. With only a Git token you get reading, outlines, Markdown writing, editing, moving and deleting files.

Projects can be referred to by ID or Overleaf URL (and by name in web mode).

Writing in Markdown

Draft in Markdown (or have your assistant draft it), then let write_markdown turn it into LaTeX inside your Overleaf project:

## Method {#sec:method}

We fine-tune the model of @sec:background on our data [@smith2020; @lee2021, p. 3].
The loss is $\mathcal{L} = -\sum_i \log p(y_i)$.

$$
\theta^* = \arg\min_\theta \mathcal{L}(\theta)
$$ {#eq:opt}

![Overview of the pipeline](figs/pipeline.pdf){#fig:pipeline width=80%}

| Model | Acc. |
|:------|-----:|
| Ours  | 91.2 |

Table: Main results {#tbl:main}

becomes \section{Method}\label{sec:method}, \cite{smith2020,lee2021}, an equation with \label{eq:opt}, a figure and a table with captions and labels.

Where it goes:

• path: "sections/method.tex": create or overwrite that file (then \input it from your main file). The main file is never overwritten, because that would delete the preamble.

• path + mode: "append": add to the end of a file, before \end{document}.

• section: "Method": replace an existing section. If your Markdown starts with a heading, the heading is replaced too; otherwise only the body is, and the existing \label is kept. Headings are leveled relative to that section.

• md_path: read a local .md file instead of passing text.

• dry_run: true: show the LaTeX without pushing anything.

The tool warns when the output needs a package your preamble doesn't load (e.g. hyperref for links, graphicx for figures).

Korean and English

Papers. English papers need no setup. For Korean papers, run setup_paper_language with language: "ko" once. It adds \usepackage{kotex} to the main file's preamble (unless a Korean package such as kotex or xeCJK is already loaded) and switches the compiler to XeLaTeX. Switching the compiler needs web mode; without it, the tool tells you how to do it in Overleaf (Menu → Settings → Compiler).

You don't have to remember this step. write_markdown warns when you write Korean into a project without Korean support, and compile adds a hint when errors come from Korean characters (Unicode character 한 (U+D55C)). The Markdown converter also handles Korean particles written directly after references and citations, so @fig:arch를 becomes \ref{fig:arch}를 and [@kim2024]에서 becomes \cite{kim2024}에서.

Responses. Set OVERLEAF_LANG=ko to get tool results, errors and warnings in Korean (the default is en). Messages that come straight from Overleaf or git stay as they are.

Credentials

Git token (OVERLEAF_GIT_TOKEN), the default and recommended way in. It uses Overleaf's official Git integration, with real commits. Git integration requires the project owner to have a paid or institutional plan. Overleaf → Account Settings → Git Integration → Generate token.

Web mode (optional, off by default; OVERLEAF_ENABLE_WEB=1 plus OVERLEAF_SESSION_COOKIE). This adds project listing, compiling, PDFs and review comments, and lets free-plan projects be read and written. Read Overleaf's terms and web mode before turning it on. To get the cookie, log in to overleaf.com, open DevTools → Application (Chrome) / Storage (Firefox) → Cookies → https://www.overleaf.com, and copy the value of overleaf_session2. It expires when you log out. A cookie on its own does nothing; web mode stays off until OVERLEAF_ENABLE_WEB=1 is also set.

To opt in, add "OVERLEAF_ENABLE_WEB": "1" and "OVERLEAF_SESSION_COOKIE": "s%3A..." to env (or -e OVERLEAF_ENABLE_WEB=1 -e OVERLEAF_SESSION_COOKIE=... for Claude Code).

Overleaf's terms and web mode

Web mode talks to Overleaf's internal web endpoints and realtime editor service, the same ones the Overleaf website uses. They are not a public API. Overleaf's Acceptable Use Policy (last modified 5 May 2026) prohibits, among other things:

• access "by any means other than our publicly supported interfaces"

• using "automated means, including robots, scripts, or spiders" to access the service

• use that is not "consistent with normal, manual human interaction", or using the service "as a processing engine or API for external systems"

• reverse engineering

• using content obtained by automated access in connection with machine learning

Git mode uses an official, documented integration, so it is the safer choice. Even so, the fair-usage and machine-learning clauses can apply to any automated use. Keep usage modest, and check the current terms yourself.

All options

How it works

• Git mode: each project is cloned into the cache dir. Reads pull at most every 15 s; every edit pulls, commits, and pushes immediately, rebasing once if someone else edited in the meantime. If the push still fails, the local copy is reset and the error says the change was not saved. The token is passed through environment-scoped git config, so it is never written to disk or shown in the process list.

• Overleaf warns that pushes from Git can lose or displace tracked changes and comments. Avoid editing passages that have active review comments through Git.

• Web mode (opt-in; used for projects without Git access): the project zip is downloaded fresh before every write, the change is applied, and the file is saved through the editor's upload endpoint (the same one as "Upload" in the Overleaf UI; missing folders are created). Overleaf applies the new content as a diff, so review comments on unchanged text stay attached (verified on overleaf.com). There are no commits; use Overleaf's History to review or undo. Projects that answer "no git access" are remembered for the session, so Git is not retried.

• File paths are confined to the project; .., absolute paths and .git/ are rejected.

FAQ

Do I need a paid Overleaf plan? For Git mode, the project owner needs a paid or institutional plan; free-plan projects answer "no git access". Web mode works on free plans, but read the terms section first.

Will it mess up my collaborators' review comments? Web-mode writes keep comments on unchanged text. Git pushes can lose or move them, so avoid editing commented passages through Git.

Can I undo a change? Git mode makes a real commit for every edit. In web mode, use Overleaf's History.

Does it work with a self-hosted Overleaf? Yes: set OVERLEAF_BASE_URL, and for Server Pro OVERLEAF_GIT_URL=https://<your-site>/git.

Is it official? No. It is an independent project, not affiliated with Overleaf.

Development

npm install
npm test
npm run inspect

npm run inspect opens the MCP Inspector against the local build.

Roadmap

• Reviewing tracked changes (accept / reject)

• Uploading images and other binary files

• Diffs and history

Contributions are welcome.

Acknowledgements

Inspired by mjyoo2/OverleafMCP (MIT). This is an independent rewrite.

License

MIT.

Star History