Skip to main content
Glama

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

notebooklm-py a secas

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 (--profile)

En caliente, account_use

Repetir notebook en cada llamada

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é

account_list

Ver las cuentas de Google configuradas (una por perfil, cada una con su cuota)

account_use(profile)

Elegir cuenta en caliente; upstream ata el perfil al proceso, aquí no

notebook_use(ref)

Fijar el notebook activo; luego se puede omitir notebook en las 33 tools

session_status

En qué cuenta y notebook estamos

health

Qué anda y qué no: auth, config, cuentas — con una lista fix de qué correr

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

  • uv para instalar y correr (instalación)

  • notebooklm-py[mcp,browser,headless]==0.8.0rc1 — única dependencia directa; trae fastmcp, el cliente RPC, el CLI notebooklm y las 33 tools. uv la 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 sync

Alta 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.json que 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 9421

Uso

Flujo típico desde el agente:

  1. account_list() → account_use("personal")

  2. notebook_list() → notebook_use("Mi investigación") (acepta título, prefijo único o id)

  3. source_add(...) para meter fuentes, chat_ask(...) para preguntar

  4. studio_generate(...) para audio, video, slide-deck, infographic, mind-map, report o quiz

  5. studio_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 notebook

Lí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_import no 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 tools
account_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_uploadA
Read-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 ~timeout s; 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 via source_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_mode is a preset — one of default / learning-guide / concise / detailed. It replaces the whole block, so it can't be combined with goal / response_length (that's rejected).

  • goal (custom persona; selects the CUSTOM goal) and response_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_deleteA
Destructive

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_describeA
Read-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_listA
Read-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:

  • note omitted → create a new note; title AND content are both required. Returns status="created".

  • note given (a note name or id) → update that note; supply title and/or content (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. Returns status="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_statusA
Read-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_infoA
Read-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

share_remove_userA
Destructive

Remove a user's access to a notebook. Accepts a notebook name or ID.

Confirm-gated: called with confirm=False (default) it does NOT mutate — it returns a needs_confirmation preview. Call with confirm=True to actually remove the user.

Inputs: email (required), notebook (required), confirm. Returns: object

share_set_accessA

Set a notebook's link-access settings. Accepts a notebook name or ID.

Provide public (True = anyone-with-link, False = restricted) and/or view_level (full or chat). Public widening (public=True on a restricted notebook) returns a needs_confirmation preview unless confirm=True; restricting and view_level changes are not gated.

Returns the updated status (or preview). view_level is echoed only when set here (the read API can't report it); with both fields it is applied before public so a partial failure fails closed.

Inputs: notebook (required), public, confirm, view_level. Returns: object

share_set_userA

Grant or change a user's access to a notebook. Accepts a notebook name or ID.

Confirm-gated: every grant/regrade returns a needs_confirmation preview unless confirm=True. Upsert by email (one backend op for an add or a permission change). permission: editor or viewer (not OWNER). notify (default False) emails the user on grant/re-grade; message is an optional welcome note. Returns the updated status (or a preview).

Inputs: email (required), notebook (required), notify, confirm, +2 more. Returns: object

share_statusA
Read-only

Get a notebook's sharing status. Accepts a notebook name or ID.

Returns is_public, access (restricted | anyone_with_link), the share_url, and the list of shared_users ({email, permission, display_name, avatar_url}). permission / access are string labels.

NOTE: view_level is intentionally NOT returned here — the read API does not report it (it would always read "full"). Set it via share_set_access, which echoes the value it just set.

Inputs: notebook (required). 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 — require url (youtube → a YouTube link).

  • text — requires text; title optional.

  • file — over stdio, requires path (a local path on the server host). Over the remote (http) connector the host filesystem is unreachable, so it returns upload_required with two actor paths: human_upload (open the signed URL in a browser) and agent_upload (an agent POSTs the bytes as the raw body); agent_instructions gives the rule (try agent_upload, else human_upload.url). Alternatively pass bytes_base64 to add a SMALL file in-channel (any transport, no signed URL): standard base64 (not URL-safe) ≤ 10,000 chars (≈ 7 KB); filename seeds the title/extension. A bigger file must take the signed URL (≤ 200 MiB).

  • drive — requires document_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_deleteA
Destructive

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_listA
Read-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_readA
Read-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. string kind/status_label) plus the extracted content, the full char_count, and a truncated flag. content is ALWAYS bounded: omitting max_chars caps it at the first 10,000 chars; raise max_chars and/or page with offset (slice [offset : offset+max_chars]). char_count stays the FULL length. content is null (char_count 0) 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_waitA
Read-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_deleteA
Destructive

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 other artifact_* tools take; resolves to its type + id.

  • artifact_type — one of audio|video|slide-deck|infographic|report| mind-map|data-table|quiz|flashcards, optionally with artifact_id (full or unique-prefix) for a specific one; omit artifact_id to 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 — requires style=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_listA
Read-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.

  • detail ladder (NOTE bodies only; read a report/data-table body via studio_download): summary (default) gives each note a bounded content_preview + char_count (artifacts add created_at + generation_prompt, the free-text prompt the artifact was generated from, null when it records none); full = whole content; compact = a id/title/type/status_label/created_at roster.

  • kind filters to one type.

  • item (name or id) fetches just that item as a 1-element list with the note's FULL content (an artifact also carries its generation_prompt); no match is NOT_FOUND. limit / offset / detail are ignored with item; kind scopes 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_statusA
Read-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_promptsA
Read-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

    A3.8/5.0

    Scored across 38 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      An 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.
      19
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      A robust MCP server for NotebookLM that provides auto-healing authentication, zero-config setup, and tools to list, query, create notebooks, and manage sources.
      6
      3
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      MCP server for querying Google NotebookLM notebooks, enabling AI assistants to list notebooks, read sources, and ask questions about them.
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      MCP 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.
      39
      MIT