Skip to content

Releases

v4.11.2

Choose a tag to compare

@github-actions github-actions released this 20 Nov 06:57

Security — the Docker noVNC console needed no password

The Docker image runs a noVNC console so you can log in to Google the first
time. It showed the browser signed in to your Google account, asked for no
password, and the shipped docker-compose.yml published it on every network
interface. Anyone who could reach port 6080 got that browser — NotebookLM and,
through the same session, the rest of the Google account — without the API
token required since 4.0.0. Reported privately by orshih6.

  • The console now asks for a password: set VNC_PASSWORD, or read the one
    generated at each start in the container logs. VNC only checks the first
    8 characters.
  • The VNC server listens inside the container only; the web console is the
    one way in.
  • docker-compose.yml and the docs publish port 6080 on 127.0.0.1. From
    another machine, use an SSH tunnel (ssh -L 6080:localhost:6080 host).
  • Once logged in, ENABLE_VNC=false turns the console off; the session is
    kept in the data volume.

If you run the container with port 6080 reachable from a network, update,
and consider signing out of other sessions from your Google account's security
page if the port was reachable by people you do not trust.

The README's Docker quick start also gained the NOTEBOOKLM_API_KEY it has
needed since 4.0.0.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.11.2

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.11.1

Choose a tag to compare

@github-actions github-actions released this 17 Nov 08:33

Copying, checked on a live account

The three copy tools from 4.11.0 were exercised against a real account after the
release. All three copy correctly from a notebook you own. Two things the
recorded replies had not shown:

  • copy_notebook returns before the sources are copied, so the sources list
    in its reply is usually empty. They appear a few seconds later — call
    list_sources on the new notebook. The tool description and API reference
    now say so.
  • A notebook you do not own — one shared with you, or a public one — cannot be
    copied from. Sources were already refused with a clear message; Studio content
    came back as an unexplained "the reply listed no copies". NotebookLM actually
    reports those items as declined, and the error now says the notebook is not
    yours and that nothing was copied.

Audio and image sources

add_source with a file already accepted audio and images; it now says so.
Checked live: an MP3 is transcribed and its transcript can be read and
questioned, and a photo of a whiteboard is read — a question answers from the
text in the picture (reading that source returns only the image link). With the
"Gemini Notebook" mobile recorder and camera, a voice memo or a photo becomes a
source you can also feed through this server.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.11.1

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.11.0

Choose a tag to compare

@github-actions github-actions released this 17 Nov 06:41

Copy a notebook, its sources, or its Studio content

Three new tools, which no other MCP server exposes:

  • copy_notebook (POST /notebooks/:id/copy) duplicates a whole notebook —
    sources and Studio content — into a new one, titled "Copy of <title>" unless
    you name it.
  • copy_sources (POST /notebooks/:id/sources/copy) copies chosen sources into
    another notebook you already have.
  • copy_content (POST /notebooks/:id/content/copy) does the same for Studio
    content (audio, video, reports, quizzes…).

Each reply maps every original id to its copy. The target notebook is never
defaulted to the active one: a copy only lands where the caller said.

A copy is not idempotent, so a failed copy is no longer replayed blindly. The
client used to retry any failed call once; for a copy, a reply lost after the
server made it would have become a second copy. A copy is now retried only after
a sign-in bounce (HTTP 401/403 or UNAUTHENTICATED), which proves nothing was
written; any other failure says the copy may already have been applied and asks
you to check the target.

Request shapes and reply offsets come from teng-lin/notebooklm-py's recorded
replies. These three calls have not yet been exercised against a live account
from this project — report anything unexpected.

Three new operations, regenerated into the Rust, Ruby, n8n and UTCP clients —
sixty-two operations now.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.11.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.10.0

Choose a tag to compare

@github-actions github-actions released this 13 Nov 05:56

MCP over streamable HTTP

The server now speaks MCP over HTTP, not only stdio. A client that cannot spawn
our local binary — an AI in another container, a hosted agent, a workflow runner
— reaches the same tools at POST /mcp, the streamable-HTTP transport every
remote MCP consumer speaks (requested in #42):

{ "mcpServers": { "notebooklm": { "type": "http", "url": "http://localhost:3000/mcp" } } }

It is stateless and sits behind the same host, origin and token guards as the
REST API: set NOTEBOOKLM_API_KEY and the client sends Authorization: Bearer
(or X-API-Key); leave it unset on a trusted container network and it works
without one. Both transports build from one createMcpServer factory, so a tool
behaves identically on either. /mcp is the protocol itself, not a REST
operation, so it stays out of the OpenAPI spec and out of the generated Rust,
Ruby and n8n clients — the operation count is unchanged.

Security

Raised the hono / @hono/node-server overrides past freshly published moderate
advisories (reverse-proxy path bypass, middleware and CSRF bypasses). Both are
transitive through the MCP SDK; we run our own Express, not the SDK's hono
server, so they were not reachable here — the overrides were simply pinned at
the now-vulnerable floor.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.10.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.9.0

Choose a tag to compare

@github-actions github-actions released this 11 Nov 10:57

Stop a running answer or research

A long answer or a Fast Research run that has gone wrong can now be cut short
instead of waited out. cancel_answer (REST POST /notebooks/:id/chat/cancel)
stops the active chat turn — the web UI's "Stop" — and cancel_research
(POST /notebooks/:id/research/cancel) cancels a discovery run. Both default
their target to the notebook's most recent conversation / current research task,
so a second connection can abort a batch that is still blocking the first.

Each is a single account-cheap RPC (CancelGeneration,
CancelDiscoverSourcesJob) and fire-and-forget: NotebookLM replies empty and
does not confirm, so cancelled: true means the stop was sent, not that a turn
was necessarily running — confirm by reading the chat or the research status.
For Fast Research the task id we already return is the correct cancel id; the
report-id caveat is Deep-only, which we do not expose.

Two new operations, regenerated into the Rust, Ruby, n8n and UTCP clients —
fifty-nine operations now.



Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.9.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.8.0

Choose a tag to compare

@github-actions github-actions released this 09 Nov 13:26

The live compute-meter quota, read with one call

NotebookLM's quota is compute-based: a single meter with a five-hour window and
a weekly window, each a percentage, plus a per-action table that says what kind
of work still has quota. There is no daily cap and no balance. get_usage
(REST GET /usage) reads it account-wide — no notebook — so a long batch of
questions or generations can check headroom before it starts, rather than
discovering the ceiling halfway through.

Two account-scoped reads back it: GetAccount for the compute-metering bit,
and ListQuotaSummary only when the bit is on, because a direct call on an
account without the meter returns prices over empty windows. The roadmap had
named the wrong RPC — ZwVcOc, which is GetUserSettings, not the meter —
caught by reading the protocol at its source before writing anything.

The decoder is pure and unit-tested: window elision (the server omits whichever
of used/remaining is zero), the frontend's active-window rule, and the exact
action-name map. The response carries a named schema, so the Rust, Ruby, n8n
and UTCP clients regenerated with it — fifty-seven operations now.

Also

The operation count is restated by hand in a few guards and in the standalone
skill repo; all of them moved to fifty-seven together. A test that had been red
on main since 4.7.0 — its secret-free check on the gem publish job swept in
the n8n job added after it — is fixed.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.8.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.7.0

Choose a tag to compare

@github-actions github-actions released this 07 Nov 06:31

The published specification was invalid, and nothing checked

Three descriptions in openapi.yaml held a comma inside a YAML flow mapping,
which parses as a second key. The document was therefore invalid, and every
client generator refused it outright — not a route, the whole file. It had been
that way through several releases, with every guard green, because nothing in
the build had ever asked a parser.

Reading the document did not find it. Generating a client from it found it in
one run, which is the lesson worth keeping: a generator is the first reader
of a specification that does not forgive.

The document is now linted on every push, and a second defect came out with the
first: only six of fifty-six responses declared a schema, and those six were
wrong. All fifty-six now carry a named schema, reconstructed from the reference
examples and the handler types, including the citation shape that only the
reference's second example showed. Three arrays that said "array of
something" without saying of what — a notebook's tags, an import's errors, a
notebook's collaborators — now say it; a generator turned each of them into an
untyped blob the caller had to inspect at runtime.

The UTCP manual is generated from that specification, so it inherited
everything: all 56 operations now describe what they answer, and the manual no
longer points at definitions it does not carry.

The Rust client covers the whole API, and is generated

The crate started with seven methods written by hand, which meant a route added
tomorrow reached no Rust caller and no guard noticed. The entire surface — 56
operations, 119 types, plus the synchronous twin — is now generated from the
specification and formatted before it is written, so the drift guard never
cries wolf.

Generation exposed four defects a hand-written client makes by accident. A
field we send and a field we receive want opposite defaults, because sending an
empty string asks the server for a notebook named empty string. Closing a
struct against future fields is right for what we receive and wrong for what
the caller sends — it stopped them building the request at all. An integer the
specification marks as possibly absent was becoming an untyped value, and
therefore zero on reading: exactly the trap this crate documents, where a
null offset attributes a quotation to the top of a long document. And the two
routes that answer with their own document rather than the envelope failed on
a missing success field.

The minimum supported Rust version is 1.88, verified by building with it rather
than claimed.

A Ruby client, from the same specification

gems/notebooklm publishes to RubyGems as notebooklm: the same 56
operations, generated the same way, with every response shape documented field
by field. The Ruby shelf for the consumer product was empty — no gem at all —
and the gem that fills it has no runtime dependencies, and none in its
tests either: the stub server they run against is built out of TCPServer,
which exercises the real HTTP path where a mocking library would replace the
part worth testing.

Ruby needs fewer helpers than Rust, and the gem ships none: keyword arguments
with defaults already read like a builder. What it does guarantee is the
honesty the generated types buy in Rust — an absent scalar reads as nil, never
as zero or an empty string; an absent nested shape reads as an empty shape, so
a chain holds without a guard at every hop; a field the server adds later stays
reachable, so an unknown shape is never a wall; and a refusal keeps the
server's own wording, separate from a request that never arrived.

Publishing uses RubyGems trusted publishing, which — unlike npm and crates.io —
needs no bootstrap token at all: a pending publisher can be configured before
the first version exists. So there is no gem token anywhere.

Eight capabilities to take from the Go tool

The Go command-line tool is ahead of us on sources and notes. Its eight
capabilities worth having are now in the roadmap, each naming the file to read
in its MIT-licensed source rather than a vague aspiration: content-addressed
sync with receipts, automatic splitting of oversized sources, source matching
by name, citation resolution, note rendering, label ingestion, flashcard export
and research sourcing.

Two articles

Driving it from Ruby,
and generating a client for any language in ten seconds
— measured across Python, Go and Ruby, with an honest account of what a
generated client does not give you.



Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.7.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.6.0

Choose a tag to compare

@github-actions github-actions released this 06 Nov 19:50

Retry a failed generation without losing its id

retry_content, and POST /content/:id/retry, re-queue a failed Studio
artifact in place. A failed generation used to be final: the only recourse was
to delete and regenerate, which mints a new id and invalidates every reference
the caller held — a stored id, a poll loop already watching it, a queued
download. The retry keeps the id, so all of those survive.

Shipping it uncovered the half that made it unusable. list_content filtered
on completed artifacts, so a failed generation vanished from the listing:
indistinguishable from never having been asked for, and its id unreachable,
which left the new tool with nothing to be called with. The status has carried
three values since it was written — the filter was narrower than the type it
was filling. The listing now reports all three.

Two refusals rather than cheerful lies: a reply with no artifact row throws,
naming the artifact, instead of reporting a queued retry the caller would then
poll forever; and a media address is handed over only for a finished artifact,
because a half-written one is a download that fails later for no stated reason.

Protocol details read from teng-lin/notebooklm-py (MIT) and cited in the
code; the implementation is ours.

A UTCP interface, and 56 named operations

UTCP inverts MCP: there is no protocol server. A
client reads a manual once, then calls this REST API natively, with no
intermediary. GET /utcp serves that manual, generated from our own OpenAPI
specification and rebased on whatever address the request arrived at, so one
document serves a loopback install and a reverse-proxied one alike.

The manual exists because auto-conversion is not enough. A UTCP client will
convert an OpenAPI document it fetches, in JSON or YAML — but the reference
implementation keeps an operation only if it carries an operationId, and
every one of our 56 operations was unnamed. Pointed at our specification, a
client found no tools at all. All 56 are now named, with the names our MCP
tools already use, so search_passages is search_passages on both sides
rather than something synthesised from a URL path.

The second gap the manual closes is authentication. Our specification declares
a bearer scheme; the reference converter maps apiKey, basic and oauth2,
not that one, so a converted manual calls everything unauthenticated and every
call comes back 401. The published manual asks for the key as X-API-Key,
which this server has always accepted alongside the bearer form, in the exact
shape the client's own model defines. The key itself is never in the document —
only the literal ${NOTEBOOKLM_API_KEY}, which is how a client asks for a
value from its own environment.

Field names were taken from the reference client's source, not its prose: the
RFC and the published documentation disagree with each other on them. A
release guard regenerates the manual and fails on any difference, and refuses
outright an operation added without a name.

Releases update the published documents by themselves

npm version <x> now propagates the new version to all ten places that
restate it — the plugin manifest, the registry manifest, the site config, the
README, llms.txt, the AI catalogue, the roadmap, the OpenAPI specification
and the UTCP manual — and stages them into the version commit. Pushing that
commit triggers the docs deploy, which regenerates the specification and the
manual into the published static files. Nothing in the chain is a step anyone
has to remember, and three guards fail the release if one of them is skipped.

Gemini Notebook, written where people and crawlers read

Google renamed NotebookLM to Gemini Notebook in July 2026. Both names are now
in prose on every surface that advertises us — the README, the registry
manifest, the site metadata, llms.txt, the AI catalogue and all twelve blog
posts — because the old name is still what people search for and the new one
is what the product is called.

Three use-case posts, one per interface: calling the API from a UTCP client,
driving it from Python, and a literature-review agent over the MCP tools.
Every response shape in them was read out of the handlers before publishing.
A test holds each post to a contract — title and description lengths, a slug
matching its filename, tags, keywords, a summary break and at least one
internal link — so a post cannot ship unfit to be found.

Fixed

  • The site's social preview image was a 404 on every page. og:image and
    twitter:image had pointed at a file that was never committed, so every
    share of every page rendered blank. The card now exists, and a test fails if
    the configured image is absent from disk.
  • The published OpenAPI specification was frozen at version 1.5.9, with 27
    of the 56 routes.
    website/static/openapi.yaml was a hand-maintained
    second copy that nobody had regenerated since 24 October, so the document an
    AI client or a UTCP converter actually fetches described an API two years of
    releases behind the code. A copy nobody regenerates is worse than no copy,
    because it answers confidently and wrongly. The duplicate is gone; the site
    now generates it, and the manual, on every build.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.6.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.5.0

Choose a tag to compare

@github-actions github-actions released this 30 Oct 07:39

Search the sources without paying for an answer

search_passages, and POST /notebooks/:id/search, return the indexed
passages matching a query, best rank first. Nothing is generated, so no chat
quota is spent
— which matters on a free account capped near fifty questions
a day. This is the retrieval half of research, the half an agent cannot
perform for itself; when you mean to reason over the evidence yourself, ask
for the evidence rather than for prose.

Filter by source_ids, or by source_names — an ambiguous title is an error
naming the candidates, never a silent guess. limit trims the reply to the
context you are willing to spend.

Two properties of the response are worth knowing, because both are easy to
misread. Rank is global across the notebook while the reply is grouped by
source
, so the order the server sends is not the ranking; we sort before
applying limit. And a passage starting at offset zero arrives with the
slot absent
rather than set to 0, so absent offsets are reported as absent:
guessing a zero is how a quote gets attributed to the top of a long document.

The bundled skill gained nblm.sh search to match, and says to prefer it over
asking when the evidence is what you want.

Protocol details read from teng-lin/notebooklm-py (MIT) and cited in the
code; the implementation is ours.

Also

  • Three production advisories closed (qs, @hono/node-server, and express
    which was only reported through qs): the overrides named a floor a
    published fix had already passed.
  • A version-sync rule that matched nothing used to print a green tick. Rules
    now run against normalised line endings, and a rule that has lost its target
    fails the run by name. It had let the REST spec ship a release behind.
  • dist/notebooklm.zip in the skill repo had been carrying the August files
    through several changes, and is rebuilt.


Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.5.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md

v4.4.0

Choose a tag to compare

@github-actions github-actions released this 24 Oct 19:27

Two security fixes, both reported by Umar Ahmed (ghostnshells)

The server now checks which host a request claims to be addressing
(GHSA-2fgr-6pf3-3hcx). The origin guard shipped in 4.0.0 let a request with no
Origin header through, on the stated assumption that only a direct client
omits that header. A browser omits it too, on any request it believes is
same-origin — which is what a re-pointed hostname produces. A page the user
merely visited could therefore read the library, sessions and the full health
report, unauthenticated. The new host guard runs before every other control
and refuses any name the server does not serve; loopback names and the bound
address are always accepted, so no local client is affected.
NOTEBOOKLM_ALLOWED_HOSTS names any further host, such as one behind a
reverse proxy.

A caller can no longer steer the browser anywhere but the notebook app
(GHSA-q565-44p7-45pv). Twelve routes and one tool accepted a notebook URL and
handed it to a browser that holds the user's Google session, with no check
beyond the scheme; exactly one route validated the host. The check now lives
at the chokepoint they all share, so routes written later inherit it.

Also: /health documented a behaviour it did not have. With no token
configured it returns the full report, and the comment now says so and says
why that posture is safe.



Install / upgrade: npm i -g @roomi-fields/notebooklm-mcp@4.4.0

Full changelog: https://github.com/roomi-fields/notebooklm-mcp/blob/main/CHANGELOG.md