nblm-mcp
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., "@nblm-mcp Switch to my work account and list my notebooks"
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.
nblm-mcp
Servidor MCP de NotebookLM multicuenta, con cuenta y notebook pegajosos por sesión.
Está construido encima de notebooklm-py (MIT),
que habla la RPC interna de NotebookLM (batchexecute) en vez de automatizar el DOM con
un browser headless — por eso no se desloguea cada dos por tres. Este paquete no forkea esa
base: la usa como dependencia y le pone encima sólo lo que le falta.
Por qué esto y no otro MCP de NotebookLM
MCPs basados en Playwright/DOM |
| nblm-mcp | |
Transporte | Scraping del DOM | RPC interna | RPC interna |
Se desloguea | Constantemente | No (master-token) | No (master-token) |
Varias cuentas Google | No | Una por proceso ( | En caliente, |
Repetir | Sí | Sí | No, se inyecta solo |
Tools | Pocas | 33 | 38 |
Lo de multicuenta no es cosmético: una cuenta free de NotebookLM tiene ~50 consultas/día. Poder saltar de cuenta sin reiniciar el server es la diferencia entre seguir trabajando o parar.
Related MCP server: OneClickLM
Qué añade sobre las 33 tools de upstream
Tool | Para qué |
| Ver las cuentas de Google configuradas (una por perfil, cada una con su cuota) |
| Elegir cuenta en caliente; upstream ata el perfil al proceso, aquí no |
| Fijar el notebook activo; luego se puede omitir |
| En qué cuenta y notebook estamos |
| Qué anda y qué no: auth, config, cuentas — con una lista |
Cómo funciona por dentro: el cliente que ven las tools de upstream es un proxy
(SwitchingClient) que apunta al perfil activo, y un middleware (StickyContext) rellena el
notebook que falte. Cero cambios en las 33 tools originales, así que un uv sync -U trae
las mejoras de upstream gratis.
Con más de una cuenta configurada, el middleware exige account_use antes de tocar nada —
que es el flujo que se quiere: elegir cuenta → elegir/crear notebook → trabajar.
Dependencias
Python ≥ 3.11
uvpara instalar y correr (instalación)notebooklm-py[mcp,browser,headless]==0.8.0rc1— única dependencia directa; traefastmcp, el cliente RPC, el CLInotebooklmy las 33 tools.uvla instala sola.Un browser (Chromium/Chrome) sólo la primera vez, para el login inicial de cada cuenta.
Una cuenta de Google con acceso a NotebookLM.
Instalación
git clone https://github.com/Solar2004/nblm-mcp.git
cd nblm-mcp
uv syncAlta de cuentas (una vez por cuenta, la corre el humano)
uv run notebooklm login --master-token --account tu@gmail.com -p personal
uv run notebooklm login --master-token --account otra@gmail.com -p secundaria--master-token = un sign-in en el browser y a partir de ahí re-mintea cookies solo, sin browser.
El
master_token.jsonque queda en~/.notebooklm/es una credencial durable de tu cuenta de Google: trátalo como un secreto, no lo subas a ningún repo.
Comprobar que quedó bien: uv run nblm-mcp y llamar a la tool health, o directamente
uv run notebooklm doctor.
Cablearlo a un cliente MCP
Claude Code (.mcp.json del proyecto, o claude mcp add), Claude Desktop
(claude_desktop_config.json) y cualquier otro cliente stdio:
{
"mcpServers": {
"notebooklm": {
"command": "uv",
"args": ["run", "--directory", "/ruta/absoluta/a/nblm-mcp", "nblm-mcp"]
}
}
}También habla HTTP si hace falta:
uv run nblm-mcp --transport http --host 127.0.0.1 --port 9421Uso
Flujo típico desde el agente:
account_list()→account_use("personal")notebook_list()→notebook_use("Mi investigación")(acepta título, prefijo único o id)source_add(...)para meter fuentes,chat_ask(...)para preguntarstudio_generate(...)para audio, video, slide-deck, infographic, mind-map, report o quizstudio_download(path=...)para bajar lo generado y leerlo del disco
Desde el paso 2 en adelante ya no hace falta pasar notebook en ninguna llamada.
Tests
uv run python test_server.py # sin red: gate de cuenta, cambio de cuenta, inyección de notebookLímites (heredados de la base)
Usa una API interna no documentada de Google: puede romperse sin aviso.
~50 consultas/día en cuentas free (de ahí lo de multicuenta).
research_importno es atómico.Estado en memoria del proceso: con stdio hay un proceso por sesión de agente, que es justo el alcance que se busca.
Licencia
MIT. La base notebooklm-py también es MIT. Proyecto no afiliado a Google ni a NotebookLM.
Available Tools
38 toolsaccount_listA
Lista las cuentas de Google (perfiles) disponibles para NotebookLM.
Cada perfil es una cuenta con su propia cuota. Devuelve profile,
account (email), authenticated y default. Para anadir una cuenta,
el usuario debe correr en su maquina:
notebooklm login --master-token --account EMAIL -p NOMBRE_PERFIL.
Inputs: no named parameters. Returns: object
account_useA
Elige la cuenta con la que trabajaras el resto de la sesion.
profile es el nombre que devuelve account_list. Cambiar de cuenta
suelta el notebook activo (los notebooks no se comparten entre cuentas).
Inputs: profile (required). Returns: object
await_uploadARead-only
Wait for a file uploaded via a source_add(source_type="file") link to land.
Pass the human_upload.url (or the bare token) that source_add returned.
Polls the server in-process until the browser/agent upload commits the source:
{"status":"received","source_id",...,"file":{...}}— the upload landed.{"status":"pending",...}— nothing yet after ~timeouts; re-invoke with the same link (the wait resumes; a transport reset does not lose it).{"status":"expired_or_invalid",...}— the link failed; mint a fresh one viasource_add(source_type="file").
Inputs: upload_link (required), timeout. Returns: object
chat_askA
Ask a notebook's sources a question, and/or recall prior turns. Accepts a notebook name or ID.
Pass conversation_id to continue a specific conversation; omit it to
continue the notebook's most-recent conversation (or start a new one).
source_ids (optional) scopes the question to specific sources by
id/prefix/title; omit it to query every source. It accepts a real list, a
JSON-array string, or a comma-separated string (the comma form cannot
carry a source title that itself contains a comma — use a JSON array or a
real list for those).
history (optional, default 0): the max number of prior Q&A pairs
(each a {question, answer}) to also return (oldest-first), from the
conversation as it stood before this question. There is no unbounded
"all" value — pass a generously large number (e.g. 100) for the whole
conversation. Omit question (leave it empty) with history > 0 to
recall prior pairs without asking anything new; a recall-only call also
echoes the conversation_id it read. Pass neither and the call is
rejected.
Returns the answer plus citation references (when a question is
asked). The internal raw_response debugging blob is never included.
references controls citation detail: lite (default) returns
source_id / citation_number / cited_text; full adds
chunk-level char offsets and scores.
suggest_followups (optional, default False): when True the
result also carries a suggested_prompts list of AI-suggested
follow-up questions (each a {title, prompt}), scoped to the same
source_ids and steered by question when one is given. It works on
its own too — pass it with no question (and history 0) to get
suggested questions without asking anything. When omitted/False the
result never contains a suggested_prompts key.
Inputs: notebook (required), history, question, references, +3 more. Returns: object
chat_configureA
Configure a notebook's chat behavior. Accepts a notebook name or ID.
Two mutually-exclusive ways to configure:
chat_modeis a preset — one ofdefault/learning-guide/concise/detailed. It replaces the whole block, so it can't be combined withgoal/response_length(that's rejected).goal(custom persona; selects the CUSTOM goal) andresponse_length(default/longer/shorter) set a custom config. A partial call (just one) merges with the current settings — the omitted field is preserved. Only a bare call (no preset, neither field) is rejected, as it would reset every setting to its default.
Inputs: notebook (required), goal, chat_mode, response_length. Returns: object
healthA
Diagnostico: dice que anda y que no, y que hacer si algo falla.
Se puede llamar sin haber elegido cuenta. Comprueba auth, config y
rutas de cada perfil configurado. Si ok es False, mira fix.
Inputs: no named parameters. Returns: object
notebook_createB
Create a new notebook with the given title.
Inputs: title (required). Returns: object
notebook_deleteADestructive
Delete a notebook (irreversible). Accepts a notebook name or ID.
Two-step confirmation: called with confirm=False (the default) it does
NOT delete — it returns a needs_confirmation preview of the resolved
notebook. Call again with confirm=True to perform the delete.
Inputs: notebook (required), confirm. Returns: object
notebook_describeARead-only
Fetch a notebook's AI-generated description. Accepts a notebook name or ID.
Returns the resolved notebook_id plus the AI description. Pass
include_metadata=True to additionally fetch the notebook's metadata
(details + source list) and surface it under a metadata key; the
default output (include_metadata omitted) is unchanged.
Inputs: notebook (required), include_metadata. Returns: object
notebook_listARead-only
List all notebooks (id + title + metadata).
Returns a bounded page: limit (default 50) items from offset (default
0), plus total / offset / has_more. Page forward by re-calling
with offset += limit while has_more is true.
Inputs: limit, offset. Returns: object
notebook_renameB
Rename a notebook. Accepts a notebook name or ID.
Inputs: notebook (required), new_title (required). Returns: object
notebook_useA
Fija el notebook activo (acepta titulo, prefijo unico o id).
Despues de esto puedes omitir notebook en las demas tools: se rellena
solo. Pasa otro para cambiar.
Inputs: notebook (required). Returns: object
note_saveA
Create a note, or update an existing one (upsert). Accepts a notebook name or ID.
Mode is chosen SOLELY by note:
noteomitted → create a new note;titleANDcontentare both required. Returnsstatus="created".notegiven (a note name or id) → update that note; supplytitleand/orcontent(at least one — title-only renames, content-only replaces the body). A ref that doesn't resolve is a not-found error, NEVER a stray create. Returnsstatus="updated".
Inputs: notebook (required), note, title, content. Returns: object
research_cancelA
Cancel an in-flight research run in a notebook.
Accepts a notebook name or ID and the poll_task_id to cancel — the
value from research_start / research_status. run_id is a
deprecated alias (removed in v0.9.0).
Sends the cancel unless the run is already TERMINAL (completed /
failed), which returns cancel_requested: false with the observed
status and no RPC. Otherwise returns cancel_requested: true with
run_status_before; a just-started run reading not_found /
no_research (replication lag) is cancelled too. Fire-and-forget; poll
research_status afterward to confirm.
Inputs: notebook (required), run_id, poll_task_id. Returns: object
research_importA
Import a completed research task's sources into the notebook.
Accepts a notebook name or ID and the poll_task_id to import — the
value from research_start / research_status. task_id is a
deprecated alias (removed in v0.9.0).
The id pins the task. Timeout-tolerant: a timed-out import reconciles
what committed. Idempotent: sources already present (by URL) are skipped
as already_present; allow_duplicate re-adds them.
cited_only imports only report-cited sources (all, if none resolve).
max_sources caps the count.
Inputs: notebook (required), task_id, cited_only, max_sources, +2 more. Returns: object
research_startA
Start a research session in a notebook. Accepts a notebook name or ID.
Non-blocking. Carry the returned poll_task_id into
research_status / research_import / research_cancel — the
single id that drives polling (it resolves deep vs fast for you). Poll
research_status until completed, then research_import to add
the sources.
source is web (default) or drive. mode is fast
(default) or deep (deep is web-only).
Inputs: query (required), notebook (required), mode, source. Returns: object
research_statusARead-only
Check a notebook's research status. Accepts a notebook name or ID.
Returns status (no_research|in_progress|completed|failed|not_found),
poll_task_id, the sources, and report metadata. Poll until
completed, then pass poll_task_id to research_import.
report and each source's report_markdown are omitted by default;
set include_report=True (optionally report_max_chars) to include
them, truncated to that length. report_char_count is the full size;
report_truncated flags an omitted/truncated report.
source_limit / source_offset page sources.
poll_task_id (optional) pins one of several in-flight tasks; omit it
for a single task (ambiguous with two+ running). An unmatched pin reports
not_found. task_id is a deprecated alias (removed in v0.9.0).
Inputs: notebook (required), task_id, poll_task_id, source_limit, +3 more. Returns: object
server_infoARead-only
Report the server version and local authentication health.
Returns the package version and an auth block (authenticated /
storage_exists / json_valid / cookies_present / sid_cookie /
profile). Use it to confirm the server is logged in before driving
notebook tools; if authenticated is false, run notebooklm login on
the server host.
Set include_account=True to also fetch an account block: the
signed-in identity {email, authuser} (in-memory/persisted first, then a
single live WIZ_global_data probe when authenticated — email is
None only when it can't be discovered at all) plus quota-pacing fields
{available, notebook_limit, source_limit, tier, output_language}
(output_language is the global account setting, e.g. "en"/"ja",
or None when unset or unparseable). The quota fields need a live
session (a few reads), so the block is off by default — the default call is
a fast, network-free probe. When the session is missing or stale the quota
fields degrade to {available: False, reason: ...} (identity still
included) rather than failing the whole call.
profile names the resolved storage profile the probe ran against
(e.g. "default"); the booleans are the actual health signals.
The absolute on-disk storage path is deliberately not returned: it leaks the server-host OS username / filesystem layout to any (possibly remote) caller, while telling the agent nothing it can act on.
Inputs: include_account. Returns: object
session_statusB
Dice que cuenta y que notebook estan activos ahora mismo.
Inputs: no named parameters. Returns: object
source_addA
Add a source to a notebook — single, batch, or in-channel bytes. Accepts a notebook name or ID.
Call in exactly ONE of two modes:
Single mode — pass source_type; it selects the required input:
url/youtube— requireurl(youtube→ a YouTube link).text— requirestext;titleoptional.file— over stdio, requirespath(a local path on the server host). Over the remote (http) connector the host filesystem is unreachable, so it returnsupload_requiredwith two actor paths:human_upload(open the signed URL in a browser) andagent_upload(an agent POSTs the bytes as the raw body);agent_instructionsgives the rule (tryagent_upload, elsehuman_upload.url). Alternatively passbytes_base64to add a SMALL file in-channel (any transport, no signed URL): standard base64 (not URL-safe) ≤ 10,000 chars (≈ 7 KB);filenameseeds the title/extension. A bigger file must take the signed URL (≤ 200 MiB).drive— requiresdocument_id+mime_type(one of google-doc|google-slides|google-sheets|pdf; required, no default — a wrong default fails non-Doc imports, #1827).
The single-mode content inputs are mutually exclusive — supply only the one
your source_type requires (bytes_base64 is the file alternative to
path). An explicit title for url/youtube/drive is honored via a post-add
rename; a miss returns title_override_applied: false (#1960).
Pass wait=true to block until the ONE added source finishes processing and
return the source_wait aggregate (buckets + per-bucket *_count +
total_count) with a top-level source_id (present even on timeout/failure);
timeout/interval tune the poll. wait is single-mode only and NOT for a
remote file signed-URL upload (add it, then source_wait). Without wait
the added source is echoed under source with string kind /
status_label labels; imports are ASYNCHRONOUS so the echo is usually still
processing/preparing — confirm with source_wait or
source_list(status="error"). A failed import is flagged inline
(status_label="error" + a warning); source_wait also flags a READY web
page with suspiciously thin text (dead link/soft-404/paywall).
Batch mode — pass urls (a list of http/https URLs, YouTube links
included) to add many in one call instead of one round-trip each. Each entry is
validated and added independently; the response is an explicit per-item list so
partial failure is never hidden::
{"notebook_id": …, "added": <int>, "failed": <int>,
"results": [{"input": "<url>", "status": "added", "source_id": …,
"title": …, "status_label": …, "warning"?: …},
{"input": "<url>", "status": "error",
"error": {"code": …, "message": …, "retriable": …, "hint"?: …}}]}results is positional (results[i] is for urls[i]); status is
"added" or "error" (the ADD outcome). An "added" item also carries the
source's status_label and, when the add response already reflects a failed
import, an inline warning — same failure-signaling as single mode. A per-URL
input failure (bad URL / 404 / SSRF-blocked host) isolates as an error
item; a fatal service failure (expired auth, rate limit, upstream 5xx) aborts
the whole call. Batch is URL-only: a non-URL entry (plain text, a local path,
file:///ftp://) is reported as a per-item VALIDATION error. The
single-mode named inputs (incl. bytes_base64/filename/wait) are not
valid with urls; allow_internal applies to every entry.
Inputs: notebook (required), url, path, text, +11 more.
source_add_drive_fileA
Add a Google Drive file by downloading it server-side and uploading it (supports epub/docx/txt/md/rtf/odt/csv/tsv/pdf).
Probes the Drive file and routes: a downloadable type is fetched server-side and
uploaded; a Google-native Doc/Slides/Sheet isn't downloadable and returns a pointer
error → use source_add(source_type='drive', mime_type=…) for those (or for a
Drive PDF you'd rather add by reference). Use source_add(source_type='file') when
you hold the bytes locally.
Accepts a notebook name or ID and a Drive file id or share URL (/d/<id>,
/file/d/<id>/…, ?id=<id>). The fetch runs server-side with the profile's
session, so it works on the remote (http) connector too — no upload_required
step. Processed ASYNCHRONOUSLY; pass wait=true to block until READY (else
confirm via source_wait / source_list(status="error")).
Inputs: notebook (required), document_id (required), wait, title. Returns: object
source_deleteADestructive
Delete a source (irreversible). Accepts a notebook/source name or ID.
Two-step confirmation: with confirm=False (default) it returns a
needs_confirmation preview of the resolved source without deleting;
call again with confirm=True to perform the delete.
Inputs: source (required), notebook (required), confirm. Returns: object
source_listARead-only
List a notebook's sources. Accepts a notebook name or ID.
detail (default full): full gives each source's metadata plus string
kind / status_label labels; compact returns only id / title
/ kind / status_label / created_at — a low-token roster.
Pass status to list only sources whose status_label matches (error =
a broken import's ghost row). Pass label (name or ID) to restrict to that
label's members; composes with status.
Inputs: notebook (required), label, limit, detail, +2 more. Returns: object
source_readARead-only
Read a source at one of two detail levels. Accepts a notebook/source name or ID.
detail selects what you get back (two distinct shapes):
summary— a tiny AI digest for low-token triage:{notebook_id, source_id, summary, keywords}. Cheap to fan out across many sources before deciding which to pull in full.full(DEFAULT) — the source metadata (incl. stringkind/status_label) plus the extractedcontent, the fullchar_count, and atruncatedflag.contentis ALWAYS bounded: omittingmax_charscaps it at the first 10,000 chars; raisemax_charsand/or page withoffset(slice[offset : offset+max_chars]).char_countstays the FULL length.contentisnull(char_count0) when the source isn't ready yet or has no extractable text.
output_format (text default / markdown, needs the server's
markdownify extra) and max_chars / offset apply only to
detail="full" (ignored for summary). Prefer chat_ask for
querying large sources rather than pulling the whole body.
Inputs: source (required), notebook (required), detail, offset, +2 more.
source_renameC
Rename a source. Accepts a notebook/source name or ID.
Inputs: source (required), notebook (required), new_title (required). Returns: object
source_waitARead-only
Wait for sources to finish processing. Accepts a notebook name or ID.
Waits for a subset when sources (list or comma/JSON string) is given, a
single source when source (name or ID) is given, else every source. All
three modes return the SAME structured aggregate, so an agent never has to
branch on the shape:
{"notebook_id", "ok", "ready", "timed_out", "failed", "not_found"}plus per-bucket *_count + total_count. ready holds sources that
reached READY (with kind / status_label labels); timed_out /
failed / not_found hold {"source_id", "error"} entries. ok is
true iff all error buckets empty. Subset
and all-sources modes report partial progress (a slow or failed source no
longer discards the ones that did become ready).
A READY web-page entry may carry a non-blocking warning when its indexed
text is thin (likely dead link / soft-404 / paywall); advisory only
(still READY, still ok — verify with source_read (detail="full")).
An unresolved ref in sources / source raises NOT_FOUND before the wait —
an input error, distinct from a resolved source the backend reports missing /
failed / slow (which lands in a bucket).
Inputs: notebook (required), source, sources, timeout, +1 more.
studio_deleteADestructive
Delete a Studio item (irreversible) — a text note OR an artifact.
Accepts a notebook name or ID plus an item name-or-id ref resolved over
the merged notes+artifacts list. Routing is by resolved type: a note is
deleted via the note system; an artifact via the artifact delete RPC (which
itself clears a note-backed mind map through the note system rather than
hard-removing it — Google may garbage collect it later).
Two-step confirmation: with confirm=False (default) it returns a
needs_confirmation preview of the resolved item without deleting; call
again with confirm=True to perform the delete. Deleting an already-absent
full id is idempotent (no error) — it routes down the artifact path (a
present note would have been found in the list).
Inputs: item (required), notebook (required), confirm. Returns: object
studio_downloadA
Download a generated artifact. Accepts a notebook name or ID.
Target the artifact in ONE of two ways (exactly one):
artifact— a name-or-id ref (title / id / unique-id-prefix), the form the otherartifact_*tools take; resolves to its type + id.artifact_type— one of audio|video|slide-deck|infographic|report| mind-map|data-table|quiz|flashcards, optionally withartifact_id(full or unique-prefix) for a specific one; omitartifact_idto get the latest artifact of that type.
output_format overrides the default file format where supported:
slide-deck → pdf|pptx; quiz/flashcards → json|markdown|html.
Over stdio the artifact is written to path (required). Over the
remote (http) connector the server filesystem is unreachable, so the tool
returns a clickable resource_link plus {"status": "download_ready", "url": …} — a short-lived signed URL; path is ignored. A text kind
(report/data-table) also returns the body inline (bounded content +
char_count + truncated) for link-incapable hosts. On the remote
connector an explicit artifact_id (and output_format) is validated up
front — an unknown/ambiguous id fails immediately, not as a 400 when opened.
Inputs: notebook (required), path, artifact, artifact_id, +2 more.
studio_generateA
Start generating a studio artifact. Accepts a notebook name or ID.
Non-blocking: returns immediately with a task_id; poll
studio_status(notebook, task_id) until is_complete is true.
Exception: mind-map renders synchronously (no task_id) — its node
tree is under mind_map (or null), the map's id under mind_map_id.
artifact_type selects the artifact kind (each routes to its own
generator):
audio— podcast-style overview (audio_format: deep-dive|brief|critique|debate,audio_length: short|default|long).video— video overview (video_format: explainer|brief|cinematic|short,style: auto|custom|classic|whiteboard| kawaii|anime|watercolor|retro-print|heritage|paper-craft,style_prompt: free-text custom-style prompt — requiresstyle=custom).cinematic-video— AI-generated documentary video.slide-deck— slide deck (deck_format: detailed|presenter,deck_length: default|short).quiz/flashcards— study aids (quantity: fewer|standard|more,difficulty: easy|medium|hard).infographic— single-image infographic (orientation: landscape|portrait|square,detail: concise|standard|detailed,style: auto|sketch-note|professional|bento-grid|editorial| instructional|bricks|clay|anime|kawaii|scientific).data-table— extracted data table.mind-map— mind map (map_kind: interactive|note-backed).report— text report (report_format: briefing-doc|study-guide|blog-post|custom).
Each per-kind option is valid ONLY for the kind(s) listed above; passing one
to a different artifact_type is a validation error, not a silent no-op.
Options default to the standard choice when omitted.
source_ids (optional) scopes generation to specific sources; omit it
to use every source. It accepts a real list, a JSON-array string, or a
comma-separated string (a source title containing a comma needs the
JSON-array or list form).
instructions is free-text guidance for kinds that accept it
(including mind-map). language (optional) is a language code,
e.g. en/ja/zh_Hans.
Inputs: notebook (required), artifact_type (required), style, detail, +14 more. Returns: object
studio_listARead-only
List a notebook's Studio panel — text notes AND generated artifacts.
Accepts a notebook name or ID. Returns a merged items list; each item has
id / title / type (note or a hyphenated artifact kind); artifacts
also carry status_label / url. Bounded page of limit (default 50)
from offset, with total / offset / has_more.
detailladder (NOTE bodies only; read a report/data-table body viastudio_download):summary(default) gives each note a boundedcontent_preview+char_count(artifacts addcreated_at+generation_prompt, the free-text prompt the artifact was generated from,nullwhen it records none);full= wholecontent;compact= aid/title/type/status_label/created_atroster.kindfilters to onetype.item(name or id) fetches just that item as a 1-element list with the note's FULLcontent(an artifact also carries itsgeneration_prompt); no match is NOT_FOUND.limit/offset/detailare ignored withitem;kindscopes resolution.
Inputs: notebook (required), item, kind, limit, +2 more. Returns: object
studio_renameA
Rename a Studio item (title only) — a text note OR an artifact.
Accepts a notebook name or ID plus an item name-or-id ref resolved over
the merged notes+artifacts list (mirroring studio_delete). Routing is by
resolved type: a note is renamed through the note system, preserving its
content via a get-then-update; every artifact type — audio, video,
slide-deck, quiz, flashcards, infographic, data-table, report, and BOTH
mind-map kinds — through the artifact rename RPC (note-backed mind maps route
back through the note system inside the shared core). Callers need not know
which backing an item has.
Returns item_id / type plus the applied new_title and
is_mind_map.
Inputs: item (required), notebook (required), new_title (required). Returns: object
studio_retryA
Retry a failed Studio artifact in place (the UI "Retry" action).
Accepts a notebook/artifact name or ID. Non-blocking: on acceptance it
returns the kicked-off task_id (equal to the artifact id) and the new
status; poll studio_status(notebook, task_id) until complete. A
synchronous refusal (rate limit / quota / not-retryable) surfaces as an error.
Inputs: artifact (required), notebook (required). Returns: object
studio_statusARead-only
Poll a generation task's status. Accepts a notebook name or ID.
Stateless: pass the task_id from studio_generate. Returns status /
url / error / is_complete / media_ready; poll until done. A
pending url is provisional — trust it only if media_ready.
Inputs: task_id (required), notebook (required). Returns: object
suggest_promptsARead-only
Get AI-suggested, ready-to-send prompts for a studio surface. Accepts a notebook name or ID.
surface selects what the prompts are written for (default ask):
ask— chat questions to ask the notebook's content.audio-deep-dive/audio-brief/audio-critique/audio-debate— prompts to steer an Audio Overview in that format.video-explainer/video-short— prompts to steer a Video Overview.quiz/flashcards— prompts to steer quiz / flashcard generation.
Each result is a ready-to-send instruction you can pass to the matching
generator (chat_ask for ask; studio_generate's instructions for
the studio formats). source_ids (optional) scopes the suggestions to
specific sources; omit for all. query optionally steers the suggestions.
Related: chat_ask(suggest_followups=true) returns ask-surface
suggestions inline with a question (ask + follow-ups in one call); this tool
is the standalone selector across every surface.
Inputs: notebook (required), query, surface, source_ids. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 38 tools
Most tools target distinct resources and actions, but a few overlap: server_info, health, and session_status all cover diagnostics/status, and source_add vs source_add_drive_file could be confused. Descriptions are detailed enough to disambiguate with careful reading.
The naming is predominantly verb_noun with clear resource prefixes (notebook_, source_, studio_, research_, share_, account_). Minor deviations: server_info, session_status, and health are noun phrases, and source_add_drive_file is a long compound, but the overall pattern is consistent and predictable.
38 tools is well above the 25+ threshold and feels excessive for a single MCP server. While the domain is broad, several tools overlap (server_info/health/session_status, source_add variants) and could be consolidated, resulting in unnecessary complexity.
The tool surface covers the full lifecycle for notebooks, sources, chat, studio artifacts, research, sharing, and account management. Minor gaps exist, such as no dedicated notebook get (covered by notebook_describe) and no source update (sources are immutable), but no critical workflows are missing.
Maintenance
Related MCP Connectors
Hosted Notion MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Hosted Google Ads MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Hosted BigQuery MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Hosted OpenAI Ads MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn unofficial MCP server for Google NotebookLM that enables users to manage notebooks, add sources, ask questions with citations, and generate audio podcasts via a Playwright-based automation layer.19MIT
- AlicenseAqualityDmaintenanceA robust MCP server for NotebookLM that provides auto-healing authentication, zero-config setup, and tools to list, query, create notebooks, and manage sources.63MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for querying Google NotebookLM notebooks, enabling AI assistants to list notebooks, read sources, and ask questions about them.MIT
- AlicenseBqualityCmaintenanceMCP server that provides ~39 tools to interact with Google NotebookLM's internal API, enabling notebook management, source addition, chat queries, and Studio artifact generation through stdio, HTTP, and SSE transports.39MIT