Overleaf MCP Server
Provides access to Overleaf projects via Git integration, enabling reading of LaTeX files, document structure analysis, content extraction by section, and project management capabilities across multiple Overleaf projects.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Overleaf MCP Server show me the latest changes in my paper's introduction section"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Visualizing the bridge between Overleaf and AI through MCP
"I tried to argue with Overleaf, but it said my syntax was invalid."
Overleaf MCP
A VS Code extension and MCP server for Overleaf. Sign in once, see all your Overleaf projects in a VS Code side panel, open and edit them live, compile and read the PDF right next to your source, sync any project to a local folder, and give AI assistants (anything that speaks the Model Context Protocol) the tools to search, read, edit, and compile your papers — one project or many at a time. 🧠
🔗 Repo: https://github.com/GhoshSrinjoy/Overleaf-mcp · ⬇️ Downloads: latest release
Your Overleaf projects in the side panel, a file open live from Overleaf, and its PDF beside it.
Executive Summary
Version 2 is a rewrite around a single, faster core:
Live, not polled. The server talks to Overleaf the way the Overleaf editor does: one persistent realtime connection per project. Reading a file takes milliseconds instead of a
git pullper call, and edits are applied as small operational-transform updates that merge with whatever collaborators are typing. They show up live in their browser.See what you write. Compile on Overleaf and read the PDF in a VS Code tab: it recompiles as the project changes (your saves, collaborators, AI edits), lists errors with links to the line, and jumps between source and PDF with SyncTeX.
Works on every plan. Signing in with the Overleaf website session needs no paid Git integration and no per-project tokens. Git tokens still work for headless servers (your old
projects.jsonkeeps working).No infrastructure. Redis and BullMQ are gone. Per-project queues and file locks handle concurrency; the server is a single file you can download and run with Node.js.
Built for agents. Exact search-and-replace edits, a "suggest mode" that records AI edits as tracked changes for you to accept or reject, ripgrep plus ranked (BM25) search across projects, a LaTeX outline that follows
\input, and compile with errors reported asfile:line.
In short: Overleaf ⇄ live connection ⇄ VS Code panel + PDF preview + local folders + MCP ⇄ your AI assistant.
Related MCP server: Overleaf MCP Server
Features
VS Code extension
📚 Projects panel listing every project (pinned first, then by last update), expandable into its live file tree. Collaborators' file changes appear immediately.
✏️ Live editing of Overleaf files (
overleaf://documents): saving pushes your change; edits from collaborators or AI tools reload open files; if a document changed while you edited, your save is merged on top instead of overwriting it.📄 PDF preview next to the editor: Recompile, automatic recompiles on change or on save, draft mode, stop on first error, an errors-and-warnings list that opens the line, zoom, page navigation, download, and SyncTeX both ways (double-click the PDF → source; Show in PDF from the editor).
🔁 Local folder sync (two-way): keep a project mirrored in a folder so local LaTeX builds, git and AI file tools work on real files. Edits on both sides merge; true clashes get conflict markers.
🩺 Compile problems in the Problems panel, on the Overleaf files and on synced local copies.
🔎 Search across projects (the same engine the AI uses).
🔐 Sign in with the browser (Google, ORCID, institutional SSO, password, captcha — whatever Overleaf asks), by pasting a session cookie, or with email/password on self-hosted servers.
🔌 One-click AI client setup for command-line assistants, desktop apps and editors (list), or every one installed at once, and automatic registration with VS Code's built-in MCP support.
MCP server
21 tools, listed below. It runs inside VS Code, or on its own as a single downloadable file, an npm package, a Claude Desktop bundle, or a Docker image.
Install
Everything is on the latest release. You don't need to clone this repository; that is only for building from source.
File | For |
| The VS Code extension (panel, live editing, PDF preview, and the MCP server for every assistant on the computer) |
| The MCP server as one file, for assistants without VS Code. Needs Node.js 20+ |
| Claude Desktop: open it to install (Settings → Extensions → Install Extension…) |
| The npm package, for |
VS Code
Download and install in one step:
# Windows (PowerShell)
Invoke-WebRequest https://github.com/GhoshSrinjoy/Overleaf-mcp/releases/latest/download/overleaf-mcp.vsix -OutFile "$env:TEMP\overleaf-mcp.vsix"; code --install-extension "$env:TEMP\overleaf-mcp.vsix"# macOS / Linux
curl -fsSL -o /tmp/overleaf-mcp.vsix https://github.com/GhoshSrinjoy/Overleaf-mcp/releases/latest/download/overleaf-mcp.vsix && code --install-extension /tmp/overleaf-mcp.vsixOr without a terminal: download overleaf-mcp.vsix from the latest release, then in VS Code open the Extensions view → … menu → Install from VSIX… and pick the file. If VS Code was already open, run Developer: Reload Window afterwards. (On macOS, if code is not found, run Shell Command: Install 'code' command in PATH in VS Code first.)
Then click the Overleaf icon in the activity bar → Sign in. A browser window opens on the Overleaf login page; log in as usual and it closes by itself. Your projects appear in the panel. To give other assistants access, open the panel menu (…) → Connect an AI Client… and pick one, or Every AI tool found on this computer.
Self-hosted Overleaf (Community Edition / Server Pro)? Run Overleaf: Use a Different Overleaf Server… first.
AI assistants without VS Code
1. Download the server (skip this if you use the VS Code extension: it installs the same file in the same place):
# macOS / Linux
mkdir -p ~/.overleaf-mcp/server && curl -fsSL -o ~/.overleaf-mcp/server/overleaf-mcp.js \
https://github.com/GhoshSrinjoy/Overleaf-mcp/releases/latest/download/overleaf-mcp.js# Windows (PowerShell)
New-Item -ItemType Directory -Force "$HOME\.overleaf-mcp\server" | Out-Null
Invoke-WebRequest https://github.com/GhoshSrinjoy/Overleaf-mcp/releases/latest/download/overleaf-mcp.js -OutFile "$HOME\.overleaf-mcp\server\overleaf-mcp.js"2. Add it to your assistant:
Assistant | macOS / Linux |
Claude Code |
|
Codex CLI |
|
GitHub Copilot CLI |
|
Gemini CLI | In |
Cursor, Windsurf, others | The same |
Claude Desktop | Open |
VS Code without the extension |
|
On Windows (PowerShell), use the full path and quote the -- (PowerShell drops a bare -- before it reaches these tools):
claude mcp add --scope user overleaf '--' node "$HOME\.overleaf-mcp\server\overleaf-mcp.js"
codex mcp add overleaf '--' node "$HOME\.overleaf-mcp\server\overleaf-mcp.js"
copilot mcp add overleaf '--' node "$HOME\.overleaf-mcp\server\overleaf-mcp.js"3. Sign in. Ask the assistant to sign in to Overleaf (the sign_in tool opens the Overleaf login page in your browser), or do it once from a terminal: node ~/.overleaf-mcp/server/overleaf-mcp.js login --browser. The session is saved in ~/.overleaf-mcp/credentials.json and shared by every assistant on the computer.
With npx instead: use npx -y https://github.com/GhoshSrinjoy/Overleaf-mcp/releases/latest/download/overleaf-live-mcp.tgz as the command (for example claude mcp add --scope user overleaf -- npx -y <that URL>). On Windows, clients that cannot start npx themselves need cmd /c npx -y <that URL>.
From source
Only needed if you want to change the code or build the files yourself:
git clone https://github.com/GhoshSrinjoy/Overleaf-mcp.git
cd Overleaf-mcp
npm install
npm run package # creates overleaf-mcp-<version>.vsix
code --install-extension overleaf-mcp-2.1.0.vsix
npm run package:release # all release files into build/releasePDF preview
Right-click a project → Open PDF Preview, or click the preview button at the top of an open .tex file. The preview opens beside the editor.
Recompile (or
Ctrl+Enter/⌘+Enterin the preview) compiles on Overleaf with the project's own compiler and main document. While the preview is open it also recompiles by itself:On any change (default): your saves, collaborators' edits and AI edits.
When you save: only your saves in VS Code (Overleaf files and synced local copies).
Never: only when you press Recompile.
Pick one under the arrow next to Recompile, or with the
overleafMcp.pdf.autoCompilesetting. A preview in a background tab catches up when you show it.Draft mode (faster, leaves images out) and Stop on first error are in the same menu.
Errors and warnings are counted in the toolbar; click the count for the list, and an entry to open its line. They are also in the Problems panel.
SyncTeX: double-click anywhere in the PDF to open the source line that produced it. In the editor, right-click → Show in PDF highlights where the cursor's line ended up. Both also work for projects synced to a local folder.
Zoom (also
Ctrl+ mouse wheel), page number, Save the PDF…, Open in your PDF viewer, the raw compile log, and find (Ctrl+F).
SyncTeX: the paragraph under the cursor, highlighted in the PDF.
When to recompile, draft mode and stop on first error.
An error from Overleaf's compile: underlined at its line, listed in the preview (click to jump) and in the Problems panel.
To give Show in PDF a shortcut, add to keybindings.json:
{ "key": "ctrl+alt+j", "command": "overleafMcp.syncToPdf", "when": "resourceScheme == overleaf" }Connecting AI clients
The extension installs a stable copy of the server at ~/.overleaf-mcp/server/overleaf-mcp.js (it survives extension updates) and shares your sign-in with it through ~/.overleaf-mcp/credentials.json. Connect an AI Client… writes the configuration for you:
Pick one assistant, or set up every one found on the computer.
Client | What the extension does |
VS Code chat (agent mode) | Registered automatically ("Overleaf" in the tools list) |
Claude Code, Codex CLI, GitHub Copilot CLI | Runs the tool's own |
Claude Desktop, Cursor, Windsurf, Gemini CLI | Adds |
Every AI tool found on this computer | All of the above for each tool that is installed |
Any HTTP client |
|
Stdio servers work with or without VS Code running. The HTTP endpoint shares the extension's live connections, so its edits show up in open editors instantly. More client-specific notes are in CLAUDE_CONFIG.md.
MCP Tools
Tool | What it does |
| Signed-in account, pinned projects, search engine |
| Opens the Overleaf login page in the browser (or takes a session cookie) and shares the session with every assistant on the computer |
| All projects with ids, last update, owner, access, tags, local sync folder |
| Pin/unpin projects; pinned projects are the default scope, and one pinned project lets tools omit |
| New blank or example project |
| File tree with the main document marked |
| Live content (optionally a line range); images come back as images |
| Exact text or regex across one, several or all projects (ripgrep), with context lines and globs |
| Relevance-ranked passages for a topic (BM25 with fuzzy and prefix matching) |
| Chapters/sections across |
| The LaTeX of one section, found by title |
| Exact search-and-replace edits, applied atomically and live; |
| Create or overwrite a file (minimal live diff for existing docs) |
| File management |
| Move files between this computer and a project |
| Compile on Overleaf; errors/warnings with |
| Project history (who changed what, when) and diffs between versions |
Every tool accepts a project by name, id or Overleaf URL, and every file in a project can be read, searched and changed. Errors explain how to recover (for example, an ambiguous oldText reports how many times it occurs; a near miss shows the passage that differs only in whitespace).
Overleaf documents cannot contain emoji or other characters outside the Basic Multilingual Plane; tools reject such edits with the offending line instead of letting Overleaf corrupt them.
Local folder sync
Right-click a project → Sync to Local Folder… (default ~/Overleaf/<project>). The folder must be new or empty.
Saving a file locally pushes it within a second; edits on Overleaf are written to the file.
Changes made while sync was off are reconciled three ways (local / Overleaf / last synced): one-sided changes are copied, edits on both sides are merged, and clashing edits get
<<<<<<<markers. Resolve and save; the resolution is pushed.Build output (
*.aux,*.log, the main PDF, …) stays local; edit.overleafignorein the folder to change that.The PDF preview, Show in PDF and compile problems work on the local copies too.
Only one VS Code window (or CLI) syncs a folder at a time; another takes over if it closes.
Without VS Code:
overleaf-mcp sync "<project>" [folder].
Headless, CLI and Docker
The server is a single self-contained file (overleaf-mcp.js on the release page, dist/mcp-server.js when built; Node ≥ 20). From npm it is called overleaf-live-mcp.
overleaf-mcp serve MCP over stdio (what AI clients launch)
overleaf-mcp --http [--port N] serve MCP over HTTP on 127.0.0.1
overleaf-mcp login --browser sign in on the real login page
overleaf-mcp login --cookie <value> or paste the overleaf_session2 cookie
overleaf-mcp login --email E --password P (self-hosted servers)
overleaf-mcp status | logout
overleaf-mcp sync <project> [folder] two-way sync until Ctrl+C(overleaf-mcp stands for node path/to/overleaf-mcp.js.)
Docker (your existing client config docker compose run --rm -T mcp keeps working):
docker compose build
docker compose run --rm mcp login --cookie "<overleaf_session2 value>" # optional: web session
docker compose run --rm -T mcp # what MCP clients runThe compose file mounts projects.json (Git tokens) and ./data (session, caches, Git clones). Without a session, projects listed in projects.json are served through the Git bridge:
{
"projects": {
"default": { "name": "My Paper", "projectId": "YOUR_PROJECT_ID", "gitToken": "YOUR_GIT_TOKEN" }
}
}Git-token projects support reading, searching, outlines, edits (commit + push, retried if someone pushed first) and history. Compile, suggest mode and project listing need the web session.
Environment variables
Variable | Purpose |
| Data directory (default |
| Session for headless use (full Cookie header, or the |
| Server (default |
| Git-token projects file (default |
| Single Git-token project without a file |
| Commit identity for Git-token edits |
| Bearer token and port for |
| Path to a ripgrep binary |
Methodology
┌──────────────── Overleaf (overleaf.com or self-hosted) ────────────────┐
│ web API (projects, zip, uploads, compile, SyncTeX, history) realtime │
└───────────────▲────────────────────────────────────────▲────────────────┘
│ session cookie │ OT updates, live events
┌──────────────────────── core (TypeScript) ──────────────────────────────────┴──────────────┐
│ SessionBackend ── realtime pool (1 connection/project, auto-reconnect) GitBackend (tokens) │
│ OverleafService: project resolution · pins · snapshot cache · ripgrep / BM25 search │
│ LaTeX outline · log parser · 3-way merge · local mirror engine │
└───────────────▲───────────────────────────────▲───────────────────────────────▲─────────────┘
│ │ │
MCP server (stdio / HTTP) VS Code extension CLI (sync, login)
AI assistants panel · overleaf:// files · Docker image
PDF preview (pdf.js) ·
local sync · problemsSign-in. A throwaway browser profile opens the real Overleaf login page; once you are in, the session cookie is captured over the DevTools protocol and the profile is deleted. Cookies live in VS Code's secret storage, mirrored (optionally) to an owner-only file for MCP servers started by other apps.
Reading. Documents are read over the realtime connection (always the latest text, including unsaved typing of collaborators). Search uses a local text snapshot per project, refreshed only when Overleaf reports the project changed.
Writing. Edits become OT updates against the version that was read; the server transforms them over concurrent edits. Overleaf's newer
history-otdocuments are supported, including tracked changes.Compiling. Compiles run on Overleaf's own servers. The preview draws the PDF with pdf.js inside a locked-down webview; SyncTeX lookups go to Overleaf with the id of the build on screen, so positions always match the PDF you see. Edits arriving over the realtime connection trigger debounced recompiles, one at a time per project.
Concurrency. Per-project queues in-process, file locks across processes, and a lease for local sync folders.
Security notes
~/.overleaf-mcp/credentials.jsonholds the Overleaf session (owner-only permissions). Turn offoverleafMcp.mcp.shareSessionWithExternalClientsto keep it only in VS Code's secret storage.Signing out also ends the session on Overleaf when it was created by the browser or password sign-in; a pasted cookie is left alone (it is your browser's session).
The HTTP endpoint listens on
127.0.0.1only, requires a bearer token, and rejects browser (cross-origin) requests.The PDF preview runs only its own scripts (strict content security policy); scripts inside PDFs are not run, and links open through VS Code's usual confirmation.
Git tokens are passed to git through its environment, never written to
.git/configor shown in process lists.projects.json,data/and*.vsixare git-ignored. Never commit tokens.
Development
npm install
npm run build # dist/extension.js, dist/mcp-server.js and the PDF viewer files in media/pdfjs
npm run typecheck
npm test # unit tests
npm run package:server # build/release: overleaf-mcp.js, overleaf-live-mcp.tgz, overleaf-mcp.mcpb
npm run package:release # the same plus overleaf-mcp.vsix
npm run screenshots # retake the README screenshots (needs the local Overleaf below)Integration tests run against a local Overleaf Community Edition in Docker (nothing touches overleaf.com):
docker compose -f test/overleaf-ce/docker-compose.yml up -d # first start takes a minute
npm run test:integration # protocol and SyncTeX, live editing (both doc formats), MCP end to end, browser sign-in, Git mode, local sync
npm run test:extension # inside a real VS Code instance: panel, live files, PDF preview, SyncTeX, auto-recompile, MCP endpoint, sync
npm run test:vsix # the same, against the packaged .vsix as installedIf port 8090 is taken, start the server with OVERLEAF_TEST_PORT=8095 and run the tests with OVERLEAF_TEST_URL=http://localhost:8095.
Press F5 in VS Code to launch an Extension Development Host.
Troubleshooting
"Not signed in … or the session has expired" — sign in again from the panel, or ask your assistant to use
sign_in(sessions expire after a few days without use).Browser sign-in doesn't open — set
overleafMcp.browserPathto Chrome, Edge, Brave or Chromium, or use Paste a session cookie.The PDF preview stays empty — check Output → Overleaf MCP; Show Compile Log shows what LaTeX said. A compile that times out on Overleaf usually finishes in draft mode.
"Too recently compiled" — Overleaf refuses compiles less than a second or two apart; the extension and the
compiletool wait and retry.Long compiles time out in Codex — raise
tool_timeout_secfor[mcp_servers.overleaf]in~/.codex/config.toml(the default is 60 seconds).Port 39847 in use — change
overleafMcp.mcp.httpServer.port; stdio clients are unaffected."Overleaf asked for a captcha" — password sign-in is blocked on overleaf.com; use the browser sign-in.
Rate limited — Overleaf limits logins (10 per 2 minutes), project downloads (10 per minute per project) and compiles; the tools back off and retry.
Citation
If you use this software in your research, please cite:
@software{overleaf_mcp_2025,
author = {GhoshSrinjoy},
title = {Overleaf MCP Server},
year = {2025},
url = {https://github.com/GhoshSrinjoy/Overleaf-mcp}
}Next Steps
🧾 Comments and review threads as MCP tools.
📦 Publish to the VS Code Marketplace and to npm (npx -y overleaf-live-mcp).
🧠 Optional semantic (embedding) search on top of BM25.
🗂️ Project-wide find-and-replace with preview.
MIT License
Available Tools
21 toolscompileCompile with OverleafA
Compiles the project on Overleaf's servers and reports LaTeX errors and warnings with file:line, so they can be fixed with edit_file. Optionally saves the PDF locally.
Inputs: draft, project, rootFile, savePdfTo, +2 more.
create_folderCreate a folderAIdempotent
Creates a folder, and any missing parent folders, in one project. Does nothing if the folder already exists; fails if a file has that path. Rarely needed: write_file, upload_file and move_file create missing folders themselves. Projects reached through a Git token cannot hold empty folders.
Inputs: path (required), project.
create_projectCreate an Overleaf projectA
Creates a new project in the signed-in Overleaf account (needs a web sign-in) and returns its name and id. "blank" starts with an empty main.tex; "example" starts from Overleaf's example document. Fill it afterwards with write_file, upload_file and create_folder.
Inputs: name (required), template.
delete_fileDelete a file or folderADestructive
Deletes a file or folder (with its contents) from a project, for every collaborator. These tools cannot undo it, but Overleaf keeps the deleted content in the project history. To rename or reorganise, use move_file instead.
Inputs: path (required), project.
download_fileDownload a project fileA
Saves a copy of one project file of any type (PDF, image, .bib, .tex) to a path on this computer, creating missing local folders and replacing a file already at that path. Changes nothing on Overleaf. Use it for binary files that read_file cannot show as text, or to work on a file with local tools; for the compiled PDF use compile with savePdfTo.
Inputs: path (required), localPath (required), project.
edit_fileEdit a fileA
Applies exact search-and-replace edits to a file, live: collaborators see the change instantly and concurrent typing is merged, not overwritten. All edits apply together or not at all, and Overleaf records them in the project history. With suggest=true the edits become tracked changes the author can accept or reject in Overleaf's review panel. Use it for targeted changes; write_file replaces a whole file.
Inputs: path (required), edits (required), dryRun, project, +1 more.
get_outlineDocument outlineARead-only
Outline of a LaTeX project (parts, chapters, sections, …) following \input/\include from the main document, with file:line for each heading and a note on included files that are missing. Read-only. Use it to see a paper's structure or find where a section lives; then get_section reads one section, or read_file reads the lines.
Inputs: project, rootFile.
get_sectionRead one sectionARead-only
Returns the LaTeX of one section (up to the next heading of the same or higher level), found by title anywhere in the document, with its file and line range. Read-only. Use it to read a section without the whole file (get_outline lists the titles); to change it, copy text from here into edit_file.
Inputs: title (required), file, project.
grepGrep across projectsARead-only
Exact text or regex search (ripgrep) across one or many projects, with file:line results and optional context. Uses local snapshots that refresh automatically when Overleaf reports changes. For topic-style questions use "search" instead.
Inputs: query (required), regex, exclude, include, +6 more.
historyProject historyARead-only
Recent changes recorded in Overleaf's project history: versions, authors, times and touched files. Use history_diff to see what changed between versions.
Inputs: path, limit, project.
history_diffDiff between versionsARead-only
Unified diff of one file between two history versions (from the history tool's vFrom→vTo numbers), e.g. to review what a collaborator changed. Read-only; binary files have no text diff.
Inputs: path (required), toVersion (required), fromVersion (required), project.
list_filesList project filesARead-only
Shows the file and folder tree of one project and marks the main document. Docs are editable text (read_file, edit_file); "binary/uploaded" files are images, PDFs and other uploads (download_file). Read-only. Use it to get exact paths before reading or editing; get_outline shows the section structure instead.
Inputs: project.
list_projectsList Overleaf projectsARead-only
Lists the projects in the signed-in Overleaf account, pinned first and then newest first, with each project's id, last update, owner, access level and tags. Read-only; needs a web sign-in (see sign_in) and keeps the list for 30 seconds. Use it to find the name or id that other tools take as "project"; list_files shows the files inside one project.
Inputs: tag, limit, query, refresh, +2 more.
move_fileMove or renameA
Moves and/or renames a file or folder inside one project, creating missing target folders. Fails if something already exists at the target path; nothing is overwritten. References in the LaTeX (\input, \includegraphics) are not updated, so fix them with edit_file afterwards. Use it rather than writing a copy and deleting the original.
Inputs: to (required), from (required), project.
pin_projectsPin projects for AI workAIdempotent
Pins or unpins projects; other pins stay as they are. Pinned projects are the default scope for grep and search, and while exactly one project is pinned, other tools can leave out "project". Pins are saved on this computer and shared with the VS Code panel; nothing changes on Overleaf. Pin the paper you are working on at the start, so later calls need no project.
Inputs: projects (required), unpin.
read_fileRead a project fileARead-only
Reads a file live from Overleaf (always the latest content, including collaborators' unsaved typing). Optionally a line range. Images (png/jpg/gif/webp) are returned as images. Read-only. To read one section by its title use get_section; for other binary files use download_file.
Inputs: path (required), endLine, project, startLine, +1 more.
searchRanked search across projectsARead-only
Relevance-ranked full-text search (BM25 with fuzzy and prefix matching) that finds passages about a topic, e.g. "related work on diffusion models", across one or many projects. Returns file:line ranges with snippets; read_file or get_section can then fetch the text. Read-only. For exact text or a regex use grep instead.
Inputs: query (required), limit, refresh, matchAll, +1 more.
sign_inSign in to OverleafA
Signs in to Overleaf so the other tools work. Without a cookie it opens the Overleaf login page in a browser window on this computer (Google, ORCID, institutional SSO and passwords all work) and waits for the person to log in. If the person gives you their overleaf_session2 cookie, pass it instead. Only needed once; the session is shared by every Overleaf tool on this computer.
Inputs: cookie, server.
statusOverleaf connection statusARead-only
Shows which Overleaf account is signed in, the server, pinned projects and the search engine in use. Call this first if other tools report sign-in problems.
Inputs: no named parameters.
upload_fileUpload a local fileADestructive
Uploads a file from this computer (e.g. a generated figure or .bib) into a project, replacing any file with the same path. For text you already have, write_file is simpler; download_file goes the other way.
Inputs: localPath (required), path, project.
write_fileCreate or overwrite a fileADestructive
Writes the full content of a text file, creating it (and missing folders) if needed. Existing docs are updated in place via a minimal live diff, so collaborators keep their cursors. Prefer edit_file for small changes.
Inputs: path (required), content (required), project, suggest, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 21 tools
Every tool targets a distinct resource+action, and descriptions explicitly disambiguate the risky pairs: search vs grep, read_file vs get_section vs download_file, edit_file vs write_file, move_file vs delete+write, create_folder vs implicit folder creation. An agent can route a request to the right tool from the names alone, with the descriptions confirming edge cases.
The bulk of the set follows a clean verb_noun pattern (list_projects, create_project, read_file, edit_file, delete_file, move_file, create_folder, upload_file, download_file, get_outline, get_section, history_diff). A handful of tools fall back to bare nouns/verbs (status, search, grep, compile, history), which are conventional but break the pattern.
21 tools is on the heavy side, but the domain genuinely spans auth, project management, file CRUD, two search modes, structure inspection, compilation, and history, so most tools earn their place. A few (status, pin_projects, create_folder) are marginal conveniences that could be folded into others.
File lifecycle is fully covered (read, write, edit, move, delete, upload, download), plus projects, search, outline/section, compile and history diffs — no dead ends in core editing workflows. Gaps are minor: no delete_project or rename_project, and no way to set the tags that list_projects reports.
Maintenance
Related MCP Connectors
Edit your Overleaf LaTeX projects from Claude and ChatGPT; every change is a real Git commit.
Persistent AI LaTeX workspace: edit and compile multi-file projects, export publication-ready PDFs.
Read and write KukGit repositories, files, issues and pull requests from an AI assistant.
A hosted LaTeX editor your assistant can actually use. Search 1,019 free templates, create and edit projects, and compile them to PDF on a real TeX Live farm, getting back the PDF or the compile log when a build fails. Thirteen tools behind OAuth 2.1, with nothing to install and nothing to run locally.
Related MCP Servers
- AlicenseBqualityDmaintenanceProvides access to Overleaf projects via Git integration, allowing Claude and other MCP clients to read LaTeX files, analyze document structure, and extract content.6185 npm355MIT
- AlicenseAqualityDmaintenanceIntegrates with Overleaf's Git feature to manage LaTeX projects directly from MCP-enabled environments, enabling cloning, syncing, and pushing changes between local machine and Overleaf.5MIT
- AlicenseNot gradedqualityFmaintenanceEnables editing Overleaf projects from Claude, with tools to list, read, edit, and sync files via Git.34 PyPIMIT
- FlicenseNot gradedqualityDmaintenanceEnables LLM agents to read and update Overleaf LaTeX papers via git, with tools for reading/writing main.tex and bibliography files.-