A1 Google Docs MCP
Reads, surgically edits, formats, comments on, and exports Google Docs — plus connects to Google via OAuth from the chat.
Read: document text as compact blocks with UTF-16 indexes, tab tree, or raw Docs API structure (styles, tables, lists, images, headers/footers)
Create & write: new documents (empty or from Markdown), insert text, tables, page/section breaks, and inline images from public URLs
Edit by exact range: replace, delete, and find-and-replace across the whole document or selected tabs
Format: character styling (bold, italic, underline, colors, fonts, sizes, links, super/subscript) and paragraph styling (headings, alignment, spacing, indents, RTL)
Structure: apply or remove bullet/numbered list presets; insert/delete table rows and columns
Export: Markdown/txt/html returned inline, or PDF, DOCX, ODT, RTF, EPUB written to a local file (10 MB cap, no comments/suggestions)
Comments: list threads with quotes and replies, create, reply, resolve, reopen, or permanently delete
Auth: check status, get setup instructions, save OAuth client JSON, start/finish in-chat login with PKCE, log out
Escape hatch: raw Docs API v1 requests (e.g.
batchUpdatefor cell merging, section styles, headers/footers, footnotes, named ranges)Guardrails: read-only/destructive tool annotations, re-read-before-edit guidance, no general-purpose Drive surface
Provides tools for reading, editing, formatting, and exporting Google Docs documents, including creating documents from Markdown, precise range edits, list/table/image handling, comment management, and export to PDF/DOCX and other formats.
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., "@A1 Google Docs MCP Read the launch plan document and summarize its unresolved comment threads."
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.
Google Docs MCP
English | Русский
A1 Google Docs MCP lets an AI app read and edit Google Docs in plain language. Read a document as text or Markdown, change an exact passage, style headings, lists and tables, work through comment threads and export the result to PDF or DOCX.
It uses the Google Docs API with your Google account. It edits by exact index ranges rather than by guesswork, and makes the limits of the Docs API explicit instead of implying that every document task is possible.
27 tools. Read a document as text, structure or Markdown, edit exact ranges, style characters and paragraphs, manage lists, tables, breaks, images and comment threads, and export to PDF, DOCX and more.
Connects from the conversation. Say "connect Google Docs": the server walks you through the OAuth client, catches Google's redirect on
127.0.0.1with PKCE and keeps the tokens itself — no config files, no restart.Edits are surgical. Changes address exact index ranges, and the server steers the assistant to re-read the document before every edit, because each change shifts the indexes after it.
Markdown both ways. Create a document from Markdown or export to Markdown, PDF, DOCX and other formats; replacing a whole document with Markdown is a separate, explicitly destructive step.
No hidden Drive surface. Export, Markdown conversion and comments use Drive endpoints internally, but the server exposes no general-purpose Drive tool.
Start with a read-only question:
Read the launch plan document and summarize its unresolved comment threads.
Connect the server · Explore use cases · Open technical documentation
See it work in a minute
You: Show me the text and comments of the launch plan document.
Assistant: Reads the document as compact text blocks and lists its comment threads. Nothing changes.
You: Rewrite the “Timeline” paragraph to say the beta starts on March 3.
Assistant: Shows the exact range it will replace and the proposed text, then asks for confirmation before editing.
You: Confirm.
Assistant: Replaces that one range. The rest of the document, its formatting and its comments stay as they were.
Related MCP server: Google Docs MCP
Contents
Quick start
You need Node.js 20+ and a Google account. Credentials are not required at install time — the server connects from the conversation.
Add the server to your AI app.
Say "connect Google Docs": the assistant walks you through creating the OAuth client and approving access without editing config files.
Ask the read-only question above.
In the app: open Settings → MCP servers, select Add server, choose STDIO, enter the command npx -y @a1-x-tech/mcp-google-docs@latest and environment variables GOOGLE_DOCS_CLIENT_ID, GOOGLE_DOCS_CLIENT_SECRET, GOOGLE_DOCS_REFRESH_TOKEN, then select Save and Restart.
From the command line:
codex mcp add google-docs \
-- npx -y @a1-x-tech/mcp-google-docs@latestcodex mcp listclaude mcp add \
--transport stdio --scope user google-docs \
-- npx -y @a1-x-tech/mcp-google-docs@latestclaude mcp listThe current official path is Settings → Extensions. For a custom desktop extension, open Advanced settings → Extension Developer → Install Extension…, select a .mcpb file and follow the prompts.
This repository currently publishes an npm stdio package and does not contain a .mcpb bundle. For Claude Desktop builds that still support local configuration, use the following JSON stdio configuration as a fallback:
{
"mcpServers": {
"google-docs": {
"command": "npx",
"args": ["-y", "@a1-x-tech/mcp-google-docs@latest"]
}
}
}In those builds, save it to ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows.
Claude Desktop MCP documentation
Add this to ~/.cursor/mcp.json on macOS/Linux or %USERPROFILE%\.cursor\mcp.json on Windows:
{
"mcpServers": {
"google-docs": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@a1-x-tech/mcp-google-docs@latest"]
}
}
}Run MCP: Open User Configuration and add:
{
"servers": {
"google-docs": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@a1-x-tech/mcp-google-docs@latest"]
}
}
}Check it with MCP: List Servers.
What you can ask it to do
Read and export a document
Read this document as text with headings and tables, and summarize it.
Show the tab tree of the handbook document.
Export the spec as Markdown; save the contract as a PDF file.
Write and edit text
Create a meeting-notes document from this Markdown.
Insert a summary paragraph after the introduction.
Replace every “Q3” with “Q4” across the document.
Delete the outdated pricing section.
Format and structure
Turn these paragraphs into a numbered list; make this line a level-2 heading.
Bold the key terms and link them to the glossary.
Insert a 3×4 table for the roadmap and fill in the header row.
Add a page break before the appendix; insert an image from a public URL.
Work with comments
List the open comment threads and summarize them.
Reply to the comment about the deadline and mark it resolved.
Add a comment quoting the sentence that needs legal review.
How a document changes
create_documentcreates a document — empty, or converted from Markdown in one call.Content is addressed by indexes — UTF-16 positions inside a tab’s body — and every insert or delete shifts all later indexes. The server steers the assistant to take fresh indexes from
read_document_textbefore each edit and to edit from the end of the document backwards.import_markdownreplaces the entire body: comment anchors, positioned objects, headers/footers and extra tabs do not survive the conversion.Tabs can be read and targeted, but the API cannot create, rename, delete or reorder them.
Comments live in Drive and are managed as threads. A new comment cannot be anchored to a text range — the anchor format is not public — so it attaches at document level, optionally quoting the text it refers to.
Exports are capped at 10 MB and do not include comments or suggestions. Inline images are fetched by Google from a public URL (PNG/JPEG/GIF, up to 50 MB and 25 megapixels); there is no channel for uploading image files.
What can change
Operation | What happens | Confirmation boundary |
Read a document, its tabs or comments | Reads content and structure | No change |
Export a document | Writes a local file when | Changes local files only |
Create a document | Adds a new document | Changes Google Docs |
Insert text, a table, a break or an image | Adds content | Changes a document |
Style text or paragraphs, manage bullets | Overwrites formatting on a range | Changes a document |
Replace or delete a range, find and replace | Removes existing content | Destructive |
Replace the whole document with Markdown | Replaces the entire body | Destructive |
Manage comments | Creates, replies, resolves or permanently deletes | Potentially destructive |
Raw API request | Can call API methods without a dedicated tool | Potentially destructive |
The AI client controls confirmation prompts. The server marks reads, writes and destructive tools so the client can distinguish an inspection from a live change.
Getting access
Google Docs requires OAuth 2.0; an API key is not enough. There are two ways in, and the first one needs no configuration files.
Connect from the chat (recommended)
Say "connect Google Docs" and the assistant runs the flow with you:
setup_instructionsprints the checklist: create or select a Google Cloud project, enable Google Docs API, configure the consent screen and create a Desktop app OAuth client.Download that client's JSON ("Download JSON") and give the assistant its path —
set_clientstores it owner-only. The secret never goes through the conversation.start_loginreturns a Google consent link. Open it on this machine and approve; the code comes back to a one-shot listener on127.0.0.1(PKCE), never through the chat.finish_loginexchanges the code and saves the tokens to~/.config/mcp-google-docs/credentials.json(mode 0600).
The tokens are re-read on every call, so the connection works immediately — no restart of the AI app. auth_status shows what is connected, logout revokes and deletes it.
Environment variables (CI, unattended installs)
Create or select a Google Cloud project and enable both the Google Docs API and the Google Drive API (export, Markdown conversion and comments go through Drive endpoints).
Configure the OAuth consent screen and create a Desktop app OAuth client.
Authorize the Google account that owns or can edit the documents. The OAuth 2.0 Playground can obtain the refresh token when Use your own OAuth credentials is enabled.
Request both scopes:
https://www.googleapis.com/auth/documents https://www.googleapis.com/auth/driveFor a narrower setup,
drive.fileis enough when export, Markdown and comments only touch documents created through this OAuth client, and the read-only pairdocuments.readonly+drive.readonlyis enough for the read-only tools.
Testing-mode OAuth refresh tokens can expire after seven days. Publish the OAuth app, or use an Internal app in a Workspace domain, when you need long-lived access. Treat the client secret and refresh token as passwords.
Configuration
Every variable is optional — with none of them the server connects from the chat.
Variable | Required | Description |
| No* | OAuth client ID. |
| No* | OAuth client secret. |
| No* | OAuth refresh token. |
| No* | Short-lived alternative to the OAuth trio (~1 hour). |
| No | Fixed loopback port for the in-chat login; useful over SSH port forwarding. |
| No | Google Docs API base URL override. |
| No | Drive API base URL override (export, Markdown, comments). |
| No | Per-request timeout; default |
| No | Temporary-error retries; default |
* Provide either the OAuth trio or an access token.
Data, limits and background work
Requests go to Google. The local server refreshes Google OAuth tokens and calls the Docs API; export, Markdown conversion and comments use Drive API endpoints internally. Its anonymous telemetry contains an installation ID, package version, AI client and platform versions, and tool names — never OAuth tokens, document content, tool arguments or prompts. For each tool call it also sends the outcome and, on failure, an excerpt of the error text with e-mails, addresses, tokens, numbers of 4+ digits and quoted text replaced by
#; a value from your request can appear in it if the error text contains it. SetASKADS_TELEMETRY=0to opt out.Google applies per-minute quotas. On
429, the server backs off and retries; reads also retry after network and5xxerrors, while writes are never replayed after an uncertain failure — a replayed write could duplicate the edit.There is no background polling. The server runs only when called. If your AI app supports scheduled tasks, it can check a document or its comments periodically.
Technical documentation
MCP capability catalog — task-oriented pages for every tool.
Support
Found a bug or need a scenario? Create an issue or write in Telegram.
Available Tools
27 toolsauth_statusGoogle connection statusARead-onlyIdempotent
Shows whether this server is connected to Google: token presence and source (env variables or a stored in-chat login), expiry, the Google account email, granted vs missing OAuth scopes, where the credentials file lives and where the OAuth client comes from. Makes no network calls and never returns the token itself. Call it first when other tools report the server is not connected.
Inputs: no named parameters.
create_documentCreate a documentA
Creates a new Google Doc and returns its documentId. Without markdown it calls documents.create, which accepts ONLY a title — add content afterwards with insert_text/import_markdown. With markdown, the document is created from that Markdown via Drive conversion (headings, bold/italic, links, lists, tables and code blocks become native Docs formatting) and the result carries id (the documentId), name and mimeType. The document lands in the authorized user's My Drive root; moving or sharing it needs the Drive UI or API, which this server does not cover.
Inputs: title (required), markdown.
delete_rangeDelete a text rangeADestructive
Deletes the content in [start_index, end_index) — text, inline images, whole tables or any mix, as long as the range does not cut across a table cell boundary. Get fresh indexes from read_document_text first; every delete shifts all later indexes down. Deleting a paragraph's trailing newline merges it with the next paragraph. The tab's final newline cannot be deleted. This is final — there is no undo through the API.
Inputs: end_index (required), document_id (required), start_index (required), tab_id, +1 more.
edit_tableEdit table rows and columnsADestructive
Inserts or deletes a row/column of an existing table. The table is addressed by table_start_index — the table block's start index from read_document_text (its startIndex in get_document). action=insert_row adds next to the cell at row_index/column_index (insert_below, default true); insert_column likewise (insert_right, default true); delete_row / delete_column remove the row/column containing that cell WITH ALL ITS CONTENT — that content is unrecoverable. row_index/column_index are 0-based and default to 0. Deleting shifts every later index in the document; re-read before further edits.
Inputs: action (required), document_id (required), table_start_index (required), tab_id, +4 more.
export_documentExport a documentA
Exports the document via Drive. Text formats (markdown, txt, html) are returned inline as the tool result — format=markdown is the way to read a doc as Markdown for a round trip with import_markdown. Binary formats (pdf, docx, odt, rtf, epub) require output_path and are written to that local file (the result reports saved_to and bytes); output_path also works for text formats. output_path must be absolute, and an existing file is never overwritten unless overwrite=true. Exports are capped at 10 MB by the Drive API; comments and suggestions are not part of any export. Nothing in Google Docs changes; the only side effect is the local file when output_path is set.
Inputs: format (required), document_id (required), overwrite, output_path.
finish_loginFinish the Google loginAIdempotent
Second step: waits up to 20 s for the browser consent to finish, saves the tokens to an owner-only file and verifies the login with a read-only identity call, returning the account email and the granted scopes. After success every tool works immediately — no client restart. If the user granted only part of the requested permissions, the login is still saved and missingScopes lists what will not work. Logging in under a different Google account replaces the previous login (its refresh token is revoked best-effort) and the response carries previousAccountEmail so the change never goes unnoticed.
Inputs: no named parameters.
get_documentGet document structureARead-onlyIdempotent
Returns the raw Docs API document: title, documentId, revisionId, per-tab body with every structural element's startIndex/endIndex, textRun styles, tables, lists, inlineObjects (image ids for replace_image), headers/footers (their segment ids) and named styles. This is the exact index map that range tools consume, but it is VERBOSE — for reading content prefer read_document_text, which returns compact blocks with the same indexes. include_tabs_content=true (default) populates all tabs; suggestions_view_mode controls how unresolved suggestions render (default DEFAULT_FOR_CURRENT_ACCESS).
Inputs: document_id (required), include_tabs_content, suggestions_view_mode.
import_markdownReplace document with MarkdownADestructiveIdempotent
REPLACES the ENTIRE document content with the given Markdown via Drive conversion — the Markdown round-trip writer paired with export_document format=markdown. Supported Markdown (headings, bold/italic/strikethrough, links, ordered/unordered lists, tables, code blocks, images by URL) becomes native Docs formatting. Everything not expressed in the Markdown is LOST: existing text, comment anchors (comments survive but detach), positioned objects, headers/footers and extra tabs. For surgical edits use replace_range/style tools instead. Returns the Drive file resource (id, name, modifiedTime).
Inputs: markdown (required), document_id (required).
insert_breakInsert a page or section breakA
Inserts a break at an index (or at the end of the body when index is omitted). kind=page starts a new page; kind=section_next_page starts a new section on a new page; kind=section_continuous starts a new section on the same page. Sections carry their own margins/columns — style them via raw_request updateSectionStyle. Breaks cannot be inserted into headers, footers, footnotes or table cells. A break occupies one index position; remove one by deleting its range with delete_range.
Inputs: kind (required), document_id (required), index, tab_id, +1 more.
insert_imageInsert an imageA
Inserts an inline image fetched from a PUBLIC URL at an index (or at the end of the body when index is omitted). The URL must be reachable by Google without auth, at most 50 MB and 25 megapixels, in PNG, JPEG or GIF; there is no upload channel — a local file must be hosted somewhere public first. width_pt/height_pt set the displayed size in points (omit both for natural size capped to the page width; when only one is given the API scales the other to keep the aspect ratio). Returns the created objectId in the reply — keep it for replace_image. Delete an image by deleting its range with delete_range (it occupies one index).
Inputs: uri (required), document_id (required), index, tab_id, +3 more.
insert_tableInsert a tableA
Inserts an empty rows x columns table at an index, or at the end of the body when index is omitted. Fill the cells afterwards: read_document_text shows the new table's range and per-cell layout, then insert_text into each cell (cell content ranges are visible in get_document; each cell holds its own paragraphs). Cell merging, cell background/borders and pinned header rows are not covered by typed tools — use raw_request with mergeTableCells/updateTableCellStyle/pinTableHeaderRows.
Inputs: rows (required), columns (required), document_id (required), index, +2 more.
insert_textInsert textA
Inserts plain text at an index (UTF-16 code units; body content starts at index 1 — get indexes from read_document_text). Omit index to append at the end of the body (or of the segment when segment_id is set). Newlines in the text create new paragraphs; the text inherits the style at the insertion point — style it afterwards with style_text/style_paragraph. Every insert shifts all later indexes, so when making several edits, apply them from the END of the document backwards or re-read between edits. Returns the batchUpdate reply with the new revisionId.
Inputs: text (required), document_id (required), index, tab_id, +1 more.
list_commentsList commentsARead-onlyIdempotent
Lists the document's comment threads via the Drive API: for each comment its id, content, author displayName, createdTime/modifiedTime, resolved flag, the quoted document text it anchors to (quotedFileContent) and its replies (with their action: resolve/reopen). Paginate with page_token; include_deleted=true also returns deleted comments as tombstones. Requires a Drive scope on the OAuth token (comments are Drive data, not Docs API data). Comment ids feed manage_comment.
Inputs: document_id (required), page_size, page_token, include_deleted.
list_tabsList document tabsARead-onlyIdempotent
Returns the document's tab tree without content: tabId, title, position index and nested childTabs. Use the tabId values to target a specific tab in read_document_text and every editing tool. NOTE: the Docs API cannot create, rename, delete or reorder tabs — that is UI-only; this tool only discovers what exists.
Inputs: document_id (required).
logoutDisconnect from GoogleADestructive
Revokes the stored token at Google (oauth2.googleapis.com/revoke) and deletes the local credentials file. Tokens supplied via env variables are NOT touched — remove them from the MCP client config manually; envTokenStillSet in the response says whether any are still in effect.
Inputs: no named parameters.
manage_commentCreate, reply to, resolve or delete a commentADestructive
Manages comment threads via the Drive API. action=create adds a NEW comment (needs content; optional quoted_text cites a passage — the API cannot anchor a new comment to a live range, that anchor format is not public, so it appears at document level). action=reply adds a reply (needs comment_id + content). action=resolve closes the thread (needs comment_id; optional content posts a closing reply); action=reopen reactivates it. action=delete PERMANENTLY removes the comment and all its replies (needs comment_id) — deleting is final, resolving is the reversible way to close a thread. Get comment_id from list_comments. Requires a Drive scope on the OAuth token.
Inputs: action (required), document_id (required), content, comment_id, +1 more.
raw_requestRaw Google Docs API callADestructive
Escape hatch to call any Google Docs API v1 path directly, for requests the typed tools don't cover — e.g. a batchUpdate with mergeTableCells, updateTableCellStyle, pinTableHeaderRows, updateSectionStyle, updateDocumentStyle, createHeader/createFooter, createFootnote, named ranges, or several requests at once with writeControl.requiredRevisionId: path "v1/documents/:batchUpdate", method POST, body {"requests":[...]}. The path may carry a query string. The Bearer token is added automatically; the method defaults to GET. Only docs.googleapis.com paths are reachable — Drive endpoints are not exposed here.
Inputs: path (required), body, method.
read_document_textRead document as textARead-onlyIdempotent
Returns the document as compact readable blocks, per tab: each paragraph with its text, start/end indexes (UTF-16 code units — the coordinates insert_text/replace_range/delete_range/style tools take), named style (headings) and bullet flag; tables come as cells[row][column] plain text with the table's range. Inline images appear as [image:] placeholders (the id feeds replace_image). tab_id limits the output to one tab. Call this before any range edit — every insert/delete shifts later indexes, so indexes from before a mutation are stale.
Inputs: document_id (required), tab_id.
replace_all_textFind and replace textADestructiveIdempotent
Replaces EVERY occurrence of a literal string (no regex) across the whole document, or only in the tabs named by tab_ids. match_case defaults to true. Returns occurrencesChanged in the batchUpdate reply — 0 means the text was not found, not an error. Safer than replace_range for textual substitutions because it does not depend on indexes; use replace_range when position matters (e.g. only one of several occurrences).
Inputs: find (required), replace (required), document_id (required), tab_ids, +1 more.
replace_imageReplace an imageADestructiveIdempotent
Replaces an existing image's contents with a new image from a public URL, keeping the original's size and position (the new image is center-cropped to fit). image_object_id is the inline object id — read_document_text shows it inside [image:] placeholders, and get_document lists all ids under inlineObjects. The same URL rules as insert_image apply (public, <=50 MB, <=25 MP, PNG/JPEG/GIF).
Inputs: uri (required), document_id (required), image_object_id (required), tab_id.
replace_rangeReplace a text rangeADestructive
Replaces the content in [start_index, end_index) with new text — one atomic batchUpdate that deletes the range and inserts at its start, so nothing is lost if either step would fail. Get fresh indexes from read_document_text first: indexes are stale after ANY previous edit. The new text takes the style at start_index. Cannot cut across a table cell boundary or delete a paragraph's final newline together with only part of the next paragraph — the API rejects such ranges. An empty replacement is allowed and equals delete_range.
Inputs: text (required), end_index (required), document_id (required), start_index (required), +2 more.
set_clientSave the OAuth clientAIdempotent
Saves the OAuth client credentials from the JSON file downloaded from Google Cloud Console ('Download JSON' on a Desktop-app client). Pass the file PATH — the secret must never be pasted into the chat. The client is stored once in the shared ~/.config/mcp-google-auth/client.json (owner-only) and reused by every mcp-google-* server; tokens stay per-server. After this, call start_login.
Inputs: path (required).
set_paragraph_bulletsSet or remove list bulletsADestructiveIdempotent
Turns the paragraphs overlapping [start_index, end_index) into a list, or removes their bullets with remove=true. Presets: disc, arrow, checkbox, star, diamond (bulleted); decimal, decimal_parens, decimal_nested, upper_alpha, upper_roman, zero_decimal (numbered). Nesting follows each paragraph's leading tabs — indent with \t in insert_text before applying bullets to create sub-items. Exactly one of preset or remove is required.
Inputs: end_index (required), document_id (required), start_index (required), preset, +2 more.
setup_instructionsSetup instructionsARead-onlyIdempotent
Step-by-step checklist for connecting this server to Google: creating a Google Cloud project and a Desktop-app OAuth client, publishing the consent screen (mandatory — Testing-mode refresh tokens die after 7 days), downloading the client JSON and handing its PATH to set_client. Works without any credentials; the checklist shortens to 'enable the API + log in' when an OAuth client is already configured (one client serves the whole mcp-google-* line). Never asks the user to paste secrets into the chat.
Inputs: no named parameters.
start_loginStart the Google loginAIdempotent
First step of connecting from the chat, without editing config files or restarting the client. Returns authorizeUrl — show it to the user as a clickable link and ask them to open it in the browser ON THIS MACHINE, pick the Google account and approve access. A one-shot listener on 127.0.0.1 catches Google's redirect; the code is exchanged locally and never passes through the chat. Does not open the browser itself. The attempt lives 10 minutes; when the browser shows the success page, call finish_login.
Inputs: no named parameters.
style_paragraphStyle paragraphsADestructiveIdempotent
Applies paragraph formatting to every paragraph overlapping [start_index, end_index): named_style (normal_text, title, subtitle, heading_1..heading_6 — the way to make headings), alignment (start/center/end/justified), line_spacing (100 = single, 200 = double), space_above/space_below (points), indent_start/indent_end/indent_first_line (points), keep_with_next and direction (ltr/rtl). Only the provided fields change; at least one is required. A range inside a single paragraph styles that whole paragraph.
Inputs: end_index (required), document_id (required), start_index (required), tab_id, +11 more.
style_textStyle a text rangeADestructiveIdempotent
Applies character formatting to [start_index, end_index): bold, italic, underline, strikethrough, small_caps, font_size (points), font_family (e.g. "Roboto"), foreground_color/background_color (6-digit hex), link_url (empty string removes an existing link) and baseline_offset (superscript/subscript/none). Only the provided fields change (the fields mask is computed); at least one is required. Explicit false turns a toggle off. Get indexes from read_document_text. Styling does not shift indexes, so several style calls can safely reuse the same coordinates.
Inputs: end_index (required), document_id (required), start_index (required), bold, +12 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 27 tools
Each tool targets a distinct resource/action or a clearly separated workflow step. Overlaps like get_document vs. read_document_text and create_document vs. import_markdown are explicitly resolved by the descriptions, which direct the agent to the right tool.
Names are consistently snake_case and mostly follow a verb_noun pattern. A few exceptions like auth_status, setup_instructions, logout, and raw_request are minor deviations but remain readable and predictable.
At 27 tools the surface is heavy for a Google Docs server, especially with seven authentication/setup tools and several edit operations that could be consolidated. Each tool mostly earns its place, but the set exceeds a well-scoped range and increases selection burden.
Core document lifecycle and editing workflows are well covered: create/read/edit/format/export/import, tables, images, comments, and auth. Minor gaps remain, such as no typed delete_document or rename operation and several advanced Docs features only reachable through raw_request.
Maintenance
Related MCP Connectors
Convert, create and edit Word, PowerPoint, Excel and PDF documents from any AI agent.
Google Docs MCP Pack — read, create, and edit Google Docs via OAuth. Reuses the google_sheets…
Share HTML/Markdown documents via URL instantly. Create, edit, delete docs from any AI tool.
Document editing, AI writing, saved documents, DOCX downloads, PDF, STT, TTS and watermarking
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables comprehensive interaction with Google Docs and Google Drive through AI assistants, supporting document reading/writing, rich formatting, table/image insertion, comment management, and complete file/folder operations with secure OAuth authentication.MIT
- AlicenseNot gradedqualityBmaintenanceEnables reading and editing Google Docs documents, including creating documents, inserting and deleting content, formatting text, and performing find-and-replace operations through natural language.84 npm2MIT
- FlicenseBqualityDmaintenanceEnables AI assistants to create, read, edit, and manage Google Docs and Drive files with support for formatting, comments, tables, images, and bulk operations.571-
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to create, read, and modify Google Slides, Sheets, Docs, and Drive documents programmatically. Supports file management, content editing, and version history retrieval.528 npmMIT