notebooklm-mcp
This server automates NotebookLM/Gemini Notebook for citation-backed Q&A, notebook/source/content management, and batch research.
Ask questions with citations, sessions, notebook selection, browser/stealth controls, and citation formats.
Manage a local notebook library: discover, add, list, get, select, update, remove, search, and show stats.
Create, list, and delete NotebookLM notebooks; copy whole notebooks or selected sources/content between notebooks.
Add and manage sources: files, URLs, text, YouTube, Google Drive; list/read/rename/delete, check freshness, get guides, search passages, and manage labels.
Generate Studio artifacts: audio, video, presentations, reports, infographics, data tables, flashcards, quizzes, and mind maps; download/export, retry failed generations, revise slides, delete, or copy artifacts.
Work with notes: create notes, list/get notes, save chat to note, and convert notes to sources.
Read/delete chat history, cancel in-flight answers or research, and discover/import web research sources.
Share notebooks, export artifacts to Google Docs/Sheets, and check live compute-quota usage.
Run batch questions into a markdown/JSON vault for offline search and reuse.
Handle auth/admin: setup, logout, switch/re-auth accounts, health checks, and deep cleanup.
Enables querying Google's NotebookLM service to retrieve zero-hallucination answers synthesized from user-uploaded documentation, with support for multiple notebooks and citation-backed responses.
Supports HTTP REST API integration with Make.com, allowing automation scenarios to query NotebookLM knowledge bases for documentation-driven responses.
Provides HTTP REST API integration for n8n workflows, allowing automation tasks to query NotebookLM knowledge bases and receive synthesized answers from documentation.
Offers HTTP REST API access for Zapier integrations, enabling automated workflows to query NotebookLM notebooks and retrieve documentation-based answers.
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., "@notebooklm-mcp summarize the key points from our API documentation notebook"
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.
NotebookLM REST API + MCP server
Automate Google Gemini Notebook — formerly, and still widely known as, NotebookLM — at scale. 62-endpoint HTTP REST API for n8n / Zapier / Make / curl, an MCP server for Claude Code / Cursor / Codex, a UTCP interface for clients that call the API natively, and Rust and Ruby clients. Citation-backed Q&A, full Studio generation (audio · video · infographic · report · presentation · data table), multi-account rotation with auto-reauth across personal and Google Workspace accounts.
v4.11.2 — Node 22 is now the floor, and the last four open advisories are gone with it. The declared floor of Node 18 had quietly become fiction: three production dependencies already required Node 20 or newer, and the test matrix kept passing on 18 without exercising them. Raising it also let the third-party file globber go — its dependency chain carried four advisories with no fix upstream — replaced by Node's built-in search, now actually under test. Builds on 4.0.0, where the HTTP API stopped being open to the network and to any web page (GHSA-p69m-c5rf-g2c3): it binds loopback, refuses unlisted origins, and takes a bearer token — remote access and Docker require
NOTEBOOKLM_API_KEY, see Securing the HTTP API. Built on a dual transport — the internalbatchexecuteRPC API (10-100× faster than scraping, immune to UI rebrands) with the Playwright browser as an automatic fallback. See the changelog.
Note (July 2026): Google rebranded NotebookLM to Gemini Notebook. It is the same product, existing links redirect, and this project drives the same underlying service — the browser path was updated for the new DOM in v2.3.0 and the RPC path in v3.0.0. Package and repository keep the
notebooklmname.
Unofficial project — good to know before you start
This is not affiliated with Google. It talks to the same
batchexecuteendpoints the NotebookLM web app uses, with a browser fallback when they move. They are undocumented, so they can change without notice — when that happens we ship a fix, as we have for every change so far.Two practical notes: use a dedicated Google account for automation, and expect NotebookLM's own quotas to apply at high volume. See Disclaimer for the full text.
What You Can Build
🔗 No-code automation pipelines — The 62-endpoint REST API means NotebookLM becomes a step in n8n, Zapier, Make, or a plain curl in cron. No agent, no MCP client, no Node in your stack — just HTTP. This is the half most NotebookLM libraries don't have.
🤖 Agent tooling — The same engine over MCP for Claude Code, Cursor and Codex, with a bundled skill that primes the agent on citation formats, the daily-quota-aware batch pattern, and transport selection.
📚 Research at volume — Multi-account rotation with automatic re-authentication, built for overnight runs of 1 000+ questions across several notebooks without babysitting.
🎙️ Full Studio generation — Audio overviews, video, infographics, reports, presentations, data tables, plus flashcards, quizzes and mind maps — generated and downloaded programmatically.
Related MCP server: notebooklm-mcp
Use Cases & Recipes
NotebookLM is a grounded engine: Gemini reads your sources and answers from them, with citations. The winning pattern is to let it do the expensive reading while your own stack handles orchestration and the last mile.
Spend fewer tokens — offload the reading
🪙 Zero-token synthesis layer — Drop 30 documents in a notebook, let Gemini do the heavy analysis, and spend your agent's context only on the final polish. The reasoning happens server-side; your agent just orchestrates (
add_notebook→source_add→notebook_ask).💾 Answer cache you can re-read offline —
vault_batchwrites every answer to disk as structured JSON against a published schema, so a batch run becomes a corpus you can grep, diff, re-index, or feed to a retrieval layer — without re-querying and re-spending quota.
Wire it into things that aren't agents
⚙️ NotebookLM as an n8n / Zapier / Make step — Because it speaks plain HTTP, a citation-backed answer becomes one node in a workflow: a form submission triggers a question, the cited answer lands in a sheet, a Slack message, or a database. No agent runtime involved.
📄 Document intake pipeline — Watch a folder or an inbox, push new PDFs and URLs in as sources, and ask a standing set of questions against them on every arrival.
Grounded answers with a paper trail
🔍 Citations with the actual source text — Answers come back with source names and the quoted excerpts they rest on, extracted from the citation panel — so a claim can be checked, not just attributed.
🎓 Literature review at thesis scale — Batch 100+ research questions across multiple notebooks, rotate accounts as daily quotas run out, and resume where it stopped. Built for, and tested on, exactly this.
Get artifacts back out
🔁 One source set, every format — Fan a single notebook out to a podcast, a video, a slide deck, a report, a quiz and a mind map, then download them all locally.
In the Wild
Real deployments, not hypotheticals.
📚 A doctoral literature review at batch scale — The project was built for, and is continuously tested on, overnight runs of 1 000+ research questions spread across several notebooks: multi-account rotation picks up when a daily quota runs out, every answer is written to disk with its citations, and an interrupted run resumes instead of starting over. The batch pattern in
vault_batchexists because a thesis needed it.🔌 Replacing a RAG engine with the REST API —
musnymubarak/Calim_Docswapped a Gemini-based retrieval engine for this project's HTTP API, running it as a Docker service (notebooklm:3000) behind a full client and worker layer. A good illustration of the REST half: no agent runtime, no MCP client — NotebookLM simply became a backend service their Python app calls.
Built something with it? Open an issue — this section is for other people's work.
Features
Q&A with Citations
Ask questions to NotebookLM and get accurate, citation-backed answers
Source citation extraction with 5 formats: none, inline, footnotes, json, expanded (97% excerpt success rate)
Session management for multi-turn conversations with auto-reauth on session expiry
Content Generation
Generate multiple content types from your notebook sources:
Content Type | Formats | Options |
Audio Overview | Podcast-style discussion | Language (80+), custom instructions |
Video | Brief, Explainer | 6 visual styles, language, custom instructions |
Infographic | Horizontal, Vertical | Language, custom instructions |
Report | Summary, Detailed | Language, custom instructions |
Presentation | Overview, Detailed | Language, custom instructions |
Data Table | Simple, Detailed | Language, custom instructions |
Flashcards | Study cards | Language, custom instructions |
Quiz | Assessment questions | Language, custom instructions |
Mind Map | Interactive node graph | Saved to the notebook |
Video Visual Styles: classroom, documentary, animated, corporate, cinematic, minimalist
Language of generated content: pass language to any generator — a BCP-47 code (es, ja, pt_BR, zh_Hans) or a name in English or in the language itself ("Spanish", "Español"). 81 languages are accepted, and an unrecognised one is refused rather than quietly swapped for another. Set a default with NOTEBOOKLM_CONTENT_LANGUAGE; it is deliberately independent of NOTEBOOKLM_UI_LOCALE, which only picks the interface language the browser fallback reads.
Flashcards and quizzes are generated via generate_study_aid; mind maps via generate_mind_map. v3 also adds share_notebook, manage_labels, and research_sources (web/Drive source discovery) — see the changelog.
Content Download
Download Audio — WAV audio files
Download Video — MP4 video files
Download Infographic — PNG image files
Text-based content (report, presentation, data_table) is returned in the API response
Delete generated content (
content_delete) — until now a notebook accumulated every draft anyone ever asked for, with no way to remove one short of the web UI
Source Management
Add sources: Files (PDF, TXT, DOCX, audio, images), URLs, Text, YouTube videos, Google Drive
List sources: Every source with its ID and title (
source_list)Rename a source (
rename_source): fix a title in place, by id or by nameCheck freshness (
check_source_freshness): which URL / Drive sources have drifted from what they point at — the whole notebook in one call. An unanswered source is reported as unknown, never as currentRead a source's guide (
get_source_guide): NotebookLM's own summary and key topics for one sourceRead a source in full (
source_read): the exact text NotebookLM indexed — what it actually reasons over, which the web UI only shows in fragments. Quote a source verbatim, check what a PDF really yielded, or hand the raw material to another tool. Name the source instead of its ID if you prefer; an ambiguous name is refused rather than guessed. Long sources arrive one page at a time, with an explicit instruction for fetching the next — orpaginate: falsefor the whole document at once.
Notebook Summary and Chat History
What is in this notebook? (
get_notebook_summary) — NotebookLM's own summary of its sources plus the questions it suggests asking, without spending a question to find outWhat was already asked? (
get_chat_history) — read back the recorded questions and answers, newest first. An agent resuming work stops paying to ask what it already asked. NotebookLM exposes only the most recent conversation per notebookClear the history (
delete_chat_history) — the web UI's "Delete history". There is no per-turn delete: the whole conversation goes
Artifact Export and Revision
Export to Drive (
export_artifact) — send a finished artifact to Google Docs or Google SheetsRevise one slide (
revise_slide) — change a single slide from a prompt instead of regenerating the whole deck
Notebook Library
Multi-notebook management with validation and smart selection
Auto-discovery: Automatically generate metadata via NotebookLM queries
Search notebooks by keyword in name, description, or topics
Scrape notebooks: List all notebooks from NotebookLM with IDs and names
Bulk delete: Delete multiple notebooks at once
Accounts & Localization
Personal and Google Workspace accounts — recognizes both NotebookLM hosts (
notebooklm.google.comand thenotebook.google.comWorkspace alias), so Workspace sessions authenticate cleanly instead of looping on "session expired"UI-language-aware — drives NotebookLM whether its interface is in English, French, German, or Japanese (
en·fr·de·ja); add a language in a single JSON file
UTCP Interface
UTCP — the Universal Tool Calling Protocol — is the inverse of MCP: there is no protocol server and no wrapper process. A client reads a tool manual once, then calls this REST API directly, so nothing sits between the agent and the endpoint.
# The manual. 56 tools, named the same as the MCP tools.
curl -H "X-API-Key: $NOTEBOOKLM_API_KEY" http://localhost:3000/utcpGET /utcp— the manual for a running server, with every call address rebased on the address the request arrived at, so one document serves a loopback install and a reverse-proxied one alike.Also published statically at notebooklm.roomi-fields.com/utcp.json, for a client configured before the server is up.
62 named tools — the manual reuses the MCP tool names, so
search_passagesissearch_passageson both sides rather than something synthesised from a URL path. Every operation in the OpenAPI 3.1 spec carries a matchingoperationId, which also means a client pointed straight at the specification converts it correctly on its own.Authentication is declared the way UTCP clients implement it — as an
api_keyin theX-API-Keyheader, which this server accepts alongside the bearer form. The key itself is never in the manual, only the literal${NOTEBOOKLM_API_KEY}, which is how a client asks for a value from its own environment. (A client that converts the specification instead will not pick up authentication at all, since the converter does not map bearer schemes — one reason to prefer the manual.)
Generated from the specification on every release and held in step by a build
guard, so the manual cannot describe a version that is not the one you are
running. Details: REST API reference → GET /utcp.
Rust client
A typed async client lives in this repository at
crates/notebooklm-client and is published as
notebooklm on crates.io
(docs), one version per release. It covers all
62 operations — generated from the specification, with a synchronous twin
behind one feature flag.
let client = notebooklm::Client::local()?;
let answer = client.ask_question(&AskRequest::new(&id, "What is ikigai?")).await?;
println!("{}", answer.answer);It deliberately does not own a browser: the Google session is bound to the machine it was made on, expires server-side while local cookies still look valid, and needs a driver kept patched against detection. The crate talks to this server, which already does all three. The reasoning in full: driving it from Rust.
Ruby client
The same surface as a gem, in this repository at
gems/notebooklm and published as
notebooklm on RubyGems, also one
version per release. All 62 operations, generated from the same specification,
every response shape documented field by field — and no runtime dependencies.
client = NotebookLM.local
answer = client.ask(notebook.id, 'What is ikigai?')
answer.citations.each { |c| puts "[#{c.number}] #{c.source_text}" }Why a gem at all, and why it owns no browser either: driving it from Ruby.
Integration Options
MCP Protocol — Claude Code, Cursor, Codex, any MCP client
UTCP — a tool manual at
/utcp, for clients that call the REST API natively with no protocol server in between (see above)Agent Skill — ships a bundled
notebooklmskill (also standalone:roomi-fields/notebooklm-skill) that teaches the agent citation formats, the batch-to-cache pattern, and when to use which transportHTTP REST API — n8n, Zapier, Make.com, custom integrations
Docker — Isolated deployment with Docker or Docker Compose
RTFM retrieval layer —
/batch-to-vaultwrites citation-backed answers as markdown + JSON sidecars (nblm-answer-v1schema), indexable by RTFM (FTS5 + semantic) for unlimited offline queries. Ideal for academic / SOTA workflows. Guide.
Quick Start
Option 0 — Claude Code marketplace (one-liner, recommended for Claude Code users)
The fastest way to get NotebookLM into Claude Code. Distributed via the roomi-fields/claude-plugins marketplace alongside RTFM (the retrieval companion — see RTFM integration guide):
/plugin marketplace add roomi-fields/claude-plugins
/plugin install notebooklm@roomi-fieldsThat registers the MCP server and the notebooklm agent skill, runs npx -y @roomi-fields/notebooklm-mcp@<pinned-version> automatically (Node ≥ 22 required), and lets you upgrade with two commands when a new release ships: /plugin marketplace update roomi-fields then /reload-plugins. Then run npx -y -p @roomi-fields/notebooklm-mcp notebooklm-mcp-setup-auth once in a terminal to log into Google (a visible Chrome opens). To install RTFM at the same time: /plugin install rtfm@roomi-fields.
Option 1 — HTTP REST API (n8n, Zapier, Make, curl, any HTTP client)
git clone https://github.com/roomi-fields/gemini-notebook-mcp.git
cd notebooklm-mcp
npm install && npm run build
npm run setup-auth # One-time Google login
npm run start:http # Start REST API on port 3000# Citation-backed Q&A, single curl, JSON response
curl -X POST http://localhost:3000/ask \
-H 'Content-Type: application/json' \
-d '{"question": "Summarize chapter 3", "notebook_id": "your-id", "source_format": "json"}'The full surface is 33 documented endpoints — see the REST API reference. For overnight batches of 1 000+ questions, see the batch pattern.
Option 2 — MCP Mode (Claude Code, Cursor, Codex)
# Build (same package, MCP transport)
git clone https://github.com/roomi-fields/gemini-notebook-mcp.git
cd notebooklm-mcp
npm install && npm run build
# Claude Code
claude mcp add notebooklm node /path/to/notebooklm-mcp/dist/index.js
# Cursor — add to ~/.cursor/mcp.json
{
"mcpServers": {
"notebooklm": {
"command": "node",
"args": ["/path/to/notebooklm-mcp/dist/index.js"]
}
}
}Log in once — in a terminal, not through the assistant. Run the interactive Google login as a command; a visible Chrome window opens, you sign in, and the saved session is then reused by the MCP server:
npm run setup-auth # from a clone (Option 2 above)
notebooklm-mcp setup-auth # from a global install (npm i -g @roomi-fields/notebooklm-mcp)Do the login in a terminal rather than by asking the assistant "log me in": some stdio MCP clients (e.g. Claude Desktop) cap tool-call duration and cut off the up-to-10-minute interactive login before you can finish signing in (see issue #27).
Option 2b — MCP over HTTP (containers, remote clients)
Clients that cannot spawn a local process — an AI in another Docker container, a hosted
agent, a workflow runner — reach the same MCP tools over streamable HTTP. Start the HTTP
server (Option 1) and point the client at /mcp:
{
"mcpServers": {
"notebooklm": {
"type": "http",
"url": "http://localhost:3000/mcp"
}
}
}Stateless, and behind the same auth as the REST API: set NOTEBOOKLM_API_KEY and the client
sends Authorization: Bearer <key>; leave it unset on a trusted container network and it
works without one (issue #42).
Option 3 — Docker (NAS, server, headless)
# Build and run
docker build -t notebooklm-mcp .
export NOTEBOOKLM_API_KEY=$(openssl rand -hex 32)
docker run -d --name notebooklm-mcp -p 3000:3000 -p 127.0.0.1:6080:6080 \
-e NOTEBOOKLM_API_KEY -v notebooklm-data:/data notebooklm-mcp
# Authenticate via noVNC (loopback only; from another machine: ssh -L 6080:localhost:6080 host)
# 1. Open http://localhost:6080/vnc.html, password: docker logs notebooklm-mcp | grep Password
# 2. Run: curl -X POST http://localhost:3000/setup-auth -H "Authorization: Bearer $NOTEBOOKLM_API_KEY" \
# -H 'Content-Type: application/json' -d '{"show_browser":true}'
# 3. Login to Google in the VNC windowSee Docker Guide for NAS deployment (Synology, QNAP).
Documentation
Full docs site: https://notebooklm.roomi-fields.com/ · OpenAPI 3.1 spec · UTCP manual
Guide | Description |
Step-by-step setup for HTTP and MCP modes | |
Environment variables and security | |
Complete HTTP endpoint documentation (62 endpoints) | |
Production batch pattern with auto-reauth and rotation | |
Pipeline pattern: NotebookLM as one-shot ingestion, RTFM as retrieval layer. | |
Workflow automation setup | |
Common issues and solutions | |
Multi-notebook management | |
Autonomous metadata generation | |
Audio, video, infographic, report, presentation | |
Multiple accounts with TOTP auto-reauth | |
Docker and Docker Compose deployment | |
Run Claude Desktop + HTTP simultaneously | |
Feature matrix vs the upstream MCP-only server | |
Profile locking (solved in v1.3.6+) | |
i18n system for multilingual UI support |
Roadmap
See ROADMAP.md for planned features and version history.
Latest releases:
v4.11.2 (2026-11-20) — Security — the Docker noVNC console needed no password
v4.11.1 (2026-11-17) — Copying, checked on a live account · Audio and image sources
v4.11.0 (2026-11-17) — Copy a notebook, its sources, or its Studio content
v4.10.0 (2026-11-13) — MCP over streamable HTTP
v4.9.0 (2026-11-11) — Stop a running answer or research
v4.8.0 (2026-11-09) — The live compute-meter quota, read with one call
v4.7.0 (2026-11-07) — The published specification was invalid, and nothing checked · The Rust client covers the whole API, and is generated · and more
v4.6.0 (2026-11-06) — Retry a failed generation without losing its id · A UTCP interface, and 56 named operations · and more
v4.5.0 (2026-10-30) — Search the sources without paying for an answer
v4.4.0 (2026-10-24) — Two security fixes, both reported by Umar Ahmed (ghostnshells)
Every earlier release, with the whole story of each, is in the full CHANGELOG.
Not yet implemented:
Discover sources (Web/Drive search with Fast/Deep modes)
Edit notes (create, delete, and convert are implemented)
Disclaimer
This tool automates browser interactions with NotebookLM. Use a dedicated Google account for automation. CLI tools like Claude Code can make mistakes — always review changes before deploying.
See full Disclaimer below.
Contributing
Found a bug? Have an idea? Open an issue or submit a PR!
See CONTRIBUTING.md for guidelines.
License
MIT — Use freely in your projects. See LICENSE.
Author
Romain Peyrichou — @roomi-fields
Acknowledgments
Thanks to everyone who has contributed code, ideas, and bug reports:
Khizar Jamshaid Iqbal — @KhizarJamshaidIqbal, 2025 UI selector fixes, doctor script, PII scrub
Kazik Pietka — @kpietkaa,
notebook.google.comrebrand supportRui Ruiberriz — @Excauboi,
hl=<uiLocale>on app URLs + click-through scrape fallback@he0xwhale —
note_list/note_getMCP tools@eminsnow — canonical tool names (
_over.)Julien Cantoni — @JulienCANTONI
Nils Friedrichs — @nils-friedrichs, LightNow capability badge
Teodor Tenev — @teodor-t-tenev, stdio mode exits when its client is gone instead of spinning a core
@shinjiyu — reported the open HTTP API privately, with the fix (GHSA-p69m-c5rf-g2c3)
Umar Ahmed — @ghostnshells, reported two advisories: the origin guard that trusted a missing header, and forced browser navigation
About browser automation: While I've built in humanization features (realistic typing speeds, natural delays, mouse movements), I can't guarantee Google won't detect or flag automated usage. Use a dedicated Google account for automation.
About CLI tools and AI agents: CLI tools like Claude Code, Codex, and similar AI-powered assistants are powerful but can make mistakes:
Always review changes before committing or deploying
Test in safe environments first
Keep backups of important work
AI agents are assistants, not infallible oracles
I built this tool for myself and share it hoping it helps others, but I can't take responsibility for any issues that might occur. Use at your own discretion.
Built with frustration about hallucinated APIs, powered by Google's NotebookLM
⭐ Star on GitHub if this saves you debugging time!
Available Tools
56 toolsauth_logoutADestructiveIdempotent
De-authenticate (logout) - Clears all authentication data for security. Use this when:
User wants to log out for security reasons
Removing credentials before shutting down
Clearing auth without immediately re-authenticating
This will:
Close all active browser sessions
Delete all saved authentication data (cookies, Chrome profile)
Preserve notebook library and other data
IMPORTANT: After de_auth, the server will need re-authentication via setup_auth or re_auth before making queries.
Use 'get_health' to verify de-authentication was successful (authenticated: false).
Inputs: no named parameters. Returns: data, error, success
auth_setupA
Google authentication for NotebookLM access - opens a browser window for manual login to your Google account. Returns immediately after opening the browser. You have up to 10 minutes to complete the login. Use 'get_health' tool afterwards to verify authentication was saved successfully. Use this for first-time authentication or when auto-login credentials are not available. IMPORTANT: If already authenticated, this tool will skip re-authentication. For switching accounts or rate-limit workarounds, use 're_auth' tool instead.
TROUBLESHOOTING for persistent auth issues: If setup_auth fails or you encounter browser/session issues:
Ask user to close ALL Chrome/Chromium instances
Run cleanup_data(confirm=true, preserve_library=true) to clean old data
Run setup_auth again for fresh start This helps resolve conflicts from old browser sessions and installation data.
Inputs: headless, show_browser, browser_options. Returns: data, error, success
auth_switchA
Switch to a different Google account or re-authenticate. Use this when:
NotebookLM usage limit is reached (compute-based, refreshes every 5 hours)
You want to switch to a different Google account
Authentication is broken and needs a fresh start
This will:
Close all active browser sessions
Delete all saved authentication data (cookies, Chrome profile)
Open browser for fresh Google login
After completion, use 'get_health' to verify authentication.
TROUBLESHOOTING for persistent auth issues: If re_auth fails repeatedly:
Ask user to close ALL Chrome/Chromium instances
Run cleanup_data(confirm=false, preserve_library=true) to preview old files
Run cleanup_data(confirm=true, preserve_library=true) to clean everything except library
Run re_auth again for completely fresh start This removes old installation data and browser sessions that can cause conflicts.
Inputs: headless, show_browser, browser_options. Returns: data, error, success
cancel_answerA
Stop a notebook’s in-flight answer — the UI’s “Stop” on a streaming reply. RPC-backed. Fire-and-forget: the server does not confirm, so cancelled: true means the stop was sent, not that a turn was running. Defaults to the most recent conversation.
Inputs: notebook_id, notebook_url, conversation_id. Returns: data, error, success
cancel_researchA
Cancel an in-flight Fast Research run for a notebook. RPC-backed. Fire-and-forget: the server does not validate the run id, so cancelled: true means the cancel was sent; confirm with research_sources. run_id defaults to the notebook’s current research task.
Inputs: run_id, notebook_id, notebook_url. Returns: data, error, success
check_source_freshnessA
Say whether URL / Drive sources have drifted from what they point at. Name no source to check the whole notebook. RPC-backed (no browser). stale: null means the server did not say — not that the source is current.
Inputs: source_id, notebook_id, source_name, notebook_url. Returns: data, error, success
content_copyA
Copy Studio artifacts (audio, video, reports, quizzes, slide decks…) into another existing notebook. RPC-backed. Returns, for each artifact, its original id and the id of the copy. Only from a notebook you own (not one shared with you or public). Not idempotent: a failure is never retried automatically.
Inputs: content_ids (required), notebook_id, notebook_url, target_notebook_id, +1 more. Returns: data, error, success
content_deleteADestructiveIdempotent
Delete a generated Studio artifact (audio overview, video, report, infographic, presentation, data table, flashcards, quiz) from a notebook.
Use list_content first to get the artifact id. RPC-backed (no browser).
WARNING: irreversible. Note-backed mind maps are not covered — they live in the notes system, not the Studio library.
Inputs: content_id (required), notebook_id, notebook_url. Returns: data, error, success
content_downloadAIdempotent
Download or export generated content from NotebookLM.
Supported content types:
audio_overview: Downloads as audio file (MP3)
video: Downloads as video file
infographic: Downloads as image file
presentation: Exports to Google Slides (returns URL)
data_table: Exports to Google Sheets (returns URL)
Note: Report content is text-based and returned in the generation response.
Inputs: content_type (required), session_id, output_path, notebook_url. Returns: data, error, success
content_generateA
Generate content from your NotebookLM sources.
Supported content types:
audio_overview: Audio podcast/overview (Deep Dive conversation with two AI hosts)
video: Video summary that visually explains main topics (brief or explainer format)
presentation: Slides/presentation with AI-generated content and images
report: Briefing document (2,000-3,000 words) summarizing key findings, exportable as PDF/DOCX
infographic: Visual infographic in horizontal (16:9) or vertical (9:16) format
data_table: Structured table organizing key information (exportable as CSV/Excel)
Language support: All content types support 80+ languages via the language parameter.
Video styles: Video content supports 6 visual styles via the video_style parameter: classroom, documentary, animated, corporate, cinematic, minimalist.
These content types use real NotebookLM Studio UI buttons or the generic ContentGenerator architecture that navigates the Studio panel and falls back to chat-based generation.
NOTE: Other content types (faq, study_guide, timeline, table_of_contents) are NOT currently implemented. For document-style content, use the ask_question tool.
Inputs: content_type (required), language, session_id, video_style, +2 more. Returns: data, error, success
content_listARead-onlyIdempotent
List all sources and generated content in the current notebook.
Returns:
Sources: Documents, URLs, and other uploaded materials
Generated content: Audio overviews
Inputs: session_id, notebook_url. Returns: data, error, success
delete_chat_historyA
Clear a notebook’s chat history. RPC-backed (no browser). NotebookLM has no per-turn delete: the whole conversation goes. The next question then starts a fresh conversation.
Inputs: notebook_id, notebook_url, conversation_id. Returns: data, error, success
export_artifactA
Export a finished Studio artifact to Google Docs or Google Sheets. RPC-backed. Returns the created document link when the server sends one.
Inputs: artifact_id (required), title, target, notebook_id, +1 more. Returns: data, error, success
generate_mind_mapA
Generate and save a mind map from a notebook’s sources. RPC-backed (no browser). Returns the saved mind-map id and its JSON structure.
Inputs: focus, title, language, notebook_id, +1 more. Returns: data, error, success
generate_study_aidA
Generate a study aid from a notebook’s sources: flashcards or a quiz. RPC-backed (no browser). Returns when generation completes.
Inputs: kind (required), focus, language, notebook_id, +1 more. Returns: data, error, success
get_chat_historyA
Read back the questions and answers already recorded in a notebook, newest first. RPC-backed (no browser). NotebookLM exposes only the most recent conversation, which is what you get unless you pass conversation_id.
Inputs: limit, notebook_id, notebook_url, conversation_id. Returns: data, error, success
get_notebook_summaryA
Read a notebook’s own summary of its sources and the questions it suggests asking. RPC-backed (no browser). Cheaper than asking a question to find out what is in there.
Inputs: notebook_id, notebook_url. Returns: data, error, success
get_source_guideB
Read NotebookLM’s own summary and key topics for a single source. RPC-backed. A source NotebookLM has not summarised yet returns an empty summary.
Inputs: source_id, notebook_id, source_name, notebook_url. Returns: data, error, success
get_usageA
Read the account’s live compute-meter usage (RPC-backed, account-scoped — no notebook). Returns the five-hour and weekly quota windows as percentages, their reset times, and a per-action table of what still has quota. status=disabled when the account has no meter. Use it to check headroom before a long batch of questions or generations.
Inputs: no named parameters. Returns: data, error, success
library_addA
📝 MANUAL ENTRY — Add notebook with manually specified metadata (use auto_discover_notebook instead)
When to Use
Auto-discovery failed or unavailable
User has specific metadata requirements
User prefers manual control
Conversation Workflow (Mandatory)
When the user says: "I have a NotebookLM with X"
FIRST: Try auto_discover_notebook for faster setup ONLY IF user refuses auto-discovery or it fails:
Ask URL: "What is the NotebookLM URL?"
Ask content: "What knowledge is inside?" (1–2 sentences)
Ask topics: "Which topics does it cover?" (3–5)
Ask use cases: "When should we consult it?"
Propose metadata and confirm:
Name: [suggested]
Description: [from user]
Topics: [list]
Use cases: [list] "Add it to your library now?"
Only after explicit "Yes" → call this tool
Rules
Do not add without user permission
Prefer auto_discover_notebook when possible
Do not guess metadata — ask concisely
Confirm summary before calling the tool
Example
User: "I have a notebook with n8n docs" You: "Want me to auto-generate the metadata?" (offer auto_discover_notebook first) User: "No, I'll specify it myself" You: Ask URL → content → topics → use cases; propose summary User: "Yes" You: Call add_notebook
How to Get a NotebookLM Share Link
Visit https://notebooklm.google/ → Login (free: 100 notebooks, 50 sources each, 500k words, 50 daily queries)
Click "+ New" (top right) → Upload sources (docs, knowledge)
Click "Share" (top right) → Select "Anyone with the link"
Click "Copy link" (bottom left) → Give this link to Claude
(Upgraded: Google AI Pro/Ultra gives 5x higher limits)
Inputs: url (required), name (required), topics (required), description (required), +3 more. Returns: data, error, success
library_discoverA
🚀 AUTO-DISCOVERY — Automatically generate notebook metadata via NotebookLM (RECOMMENDED)
When to Use
User provides NotebookLM URL and wants quick/automatic setup
User prefers not to manually specify metadata
Default choice for adding notebooks
Workflow
User provides NotebookLM URL
Ask confirmation: "Add '[URL]' with auto-generated metadata?"
Call this tool → NotebookLM generates name, description, tags
Show generated metadata to user for review
Benefits
✅ 30 seconds vs 5 minutes manual entry
✅ Zero-friction notebook addition
✅ Consistent metadata quality
✅ Discovers topics user might not think of
Example
User: "Add this NotebookLM: https://notebooklm.google.com/notebook/abc123" You: "Add this notebook with auto-generated metadata?" User: "Yes" You: Call auto_discover_notebook(url="https://...") → Returns: {name: "n8n-workflow-guide", description: "...", tags: [...]}
Fallback
If auto-discovery fails (rare), use add_notebook tool for manual entry.
How to Get a NotebookLM Share Link
Visit https://notebooklm.google/ → Login (free: 100 notebooks, 50 sources each, 500k words, 50 daily queries)
Click "+ New" (top right) → Upload sources (docs, knowledge)
Click "Share" (top right) → Select "Anyone with the link"
Click "Copy link" (bottom left) → Give this link to Claude
(Upgraded: Google AI Pro/Ultra gives 5x higher limits)
Inputs: url (required). Returns: data, error, success
library_getARead-onlyIdempotent
Get detailed information about a specific notebook by ID
Inputs: id (required). Returns: data, error, success
library_listARead-onlyIdempotent
List all library notebooks with metadata (name, topics, use cases, URL). Use this to present options, then ask which notebook to use for the task.
Inputs: no named parameters. Returns: data, error, success
library_removeADestructiveIdempotent
Dangerous — requires explicit user confirmation.
Confirmation Workflow
User requests removal ("Remove the React notebook")
Look up full name to confirm
Ask: "Remove '[notebook_name]' from your library? (Does not delete the actual NotebookLM notebook)"
Only on explicit "Yes" → call remove_notebook
Never remove without permission or based on assumptions.
Example: User: "Delete the old React notebook" You: "Remove 'React Best Practices' from your library?" User: "Yes" → call remove_notebook
Inputs: id (required). Returns: data, error, success
library_searchARead-onlyIdempotent
Search library by query (name, description, topics, tags). Use to propose relevant notebooks for the task and then ask which to use.
Inputs: query (required). Returns: data, error, success
library_selectAIdempotent
Set a notebook as the active default (used when ask_question has no notebook_id).
When To Use
User switches context: "Let's work on React now"
User asks explicitly to activate a notebook
Obvious task change requires another notebook
Auto-Switching
Safe to auto-switch if the context is clear and you announce it: "Switching to React notebook for this task..."
If ambiguous, ask: "Switch to [notebook] for this task?"
Example
User: "Now let's build the React frontend" You: "Switching to React notebook..." (call select_notebook)
Inputs: id (required). Returns: data, error, success
library_statsARead-onlyIdempotent
Get statistics about your notebook library (total notebooks, usage, etc.)
Inputs: no named parameters. Returns: data, error, success
library_updateAIdempotent
Update notebook metadata based on user intent.
Pattern
Identify target notebook and fields (topics, description, use_cases, tags, url)
Propose the exact change back to the user
After explicit confirmation, call this tool
Examples
User: "React notebook also covers Next.js 14" You: "Add 'Next.js 14' to topics for React?" User: "Yes" → call update_notebook
User: "Include error handling in n8n description" You: "Update the n8n description to mention error handling?" User: "Yes" → call update_notebook
Tip: You may update multiple fields at once if requested.
Inputs: id (required), url, name, tags, +4 more. Returns: data, error, success
manage_labelsA
Manage a notebook’s source labels (RPC-backed): list them, create one, or delete some. action=list (default) / create (needs name) / delete (needs label_ids).
Inputs: name, emoji, action, label_ids, +2 more. Returns: data, error, success
notebook_askA
Conversational Research Partner (NotebookLM • Gemini 2.5 • Session RAG)
No Active Notebook
Visit https://notebooklm.google to create a notebook and get a share link
Use add_notebook to add it to your library (explains how to get the link)
Use list_notebooks to show available sources
Use select_notebook to set one active
Auth tip: If login is required, use the prompt 'notebooklm.auth-setup' and then verify with the 'get_health' tool. If authentication later fails (e.g., expired cookies), use the prompt 'notebooklm.auth-repair'.
Tip: Tell the user you can manage NotebookLM library and ask which notebook to use for the current task.
Inputs: question (required), session_id, notebook_id, notebook_url, +3 more. Returns: data, error, success
notebook_copyA
Copy a whole notebook — its sources and Studio artifacts — into a new notebook. RPC-backed. Returns the new notebook id and URL. The sources are copied in the background and may not be listed in the reply yet — call list_sources a few seconds later. Only a notebook you own can be copied (not one shared with you or public). Not idempotent: a failure is never retried automatically, so check the notebook list before retrying.
Inputs: title, notebook_id, notebook_url. Returns: data, error, success
notebook_createA
Create a brand-new empty notebook directly in NotebookLM (no pre-existing URL required, unlike add_notebook which only registers an already-created notebook into the library).
Returns { notebook_url, notebook_id, name_applied, actual_name, message }.
notebook_url/notebook_id: always the FINAL UUID-based URL (the tool waits past the/notebook/creating/ctransitional URL).name_applied(boolean): whether thenameparameter actually took effect.falsemeans the notebook is still "Untitled notebook" — rename via UI if needed.actual_name(string): the title observed on the notebook after creation.
Typical workflow:
create_notebook({ name?: "my-research" })→{ notebook_url, notebook_id, name_applied, actual_name }add_source({ notebook_url, source_type: "url", source: "https://..." })ask_question({ notebook_url, question: "..." })
Note: Requires authentication. Run setup_auth first if not authenticated.
Inputs: name, show_browser. Returns: data, error, success
notebook_deleteADestructive
Delete one or more notebooks directly from NotebookLM (UI-level deletion, not just from the local library). Pass an array of notebook IDs (UUIDs from list_notebooks_from_nblm).
Returns { deleted: [...], failed: [...] } so the caller can retry or report on partial failures.
Use this to:
Bulk-clean up a NotebookLM account (e.g. test notebooks from automation runs)
Free up the 100-notebook free-tier quota
Remove notebooks no longer covered by your sources
Warning: This is irreversible at the NotebookLM side. Confirm with the user before calling.
Note: Requires authentication. Run setup_auth first if not authenticated.
Inputs: notebook_ids (required), show_browser. Returns: data, error, success
notebook_listARead-onlyIdempotent
Scrape the NotebookLM homepage to get a real list of all notebooks with their IDs and names.
This tool navigates to notebooklm.google.com and extracts:
Notebook ID (UUID from URL)
Notebook name (displayed title)
Notebook URL
Use this to:
Discover notebooks not yet in your library
Get accurate notebook IDs for automation
Verify which notebooks exist in your account
Find notebooks to delete when cleanup is needed
Note: Requires authentication. Run setup_auth first if not authenticated.
Inputs: show_browser. Returns: data, error, success
note_createA
Create a note in the NotebookLM Studio panel.
Notes are user-created annotations that appear in your notebook. Use them to save research findings, summaries, key insights, or any custom content you want to keep alongside your sources.
Notes support markdown formatting for rich text content.
Inputs: title (required), content (required), session_id, notebook_url. Returns: data, error, success
note_getB
Retrieve the full title and text content of a specific note in the NotebookLM Studio panel.
Inputs: note_title (required), note_id, session_id, notebook_url. Returns: data, error, success
note_listB
List all user notes in the NotebookLM Studio panel. Returns note titles, IDs, and timestamps (e.g. details).
Inputs: session_id, notebook_url. Returns: data, error, success
note_save_chatA
Save the current NotebookLM chat/discussion to a note.
This tool extracts all messages from the current conversation (both user questions and NotebookLM AI responses) and saves them as a formatted note in the Studio panel.
Use this to:
Preserve important research conversations
Create a summary of your discussion with NotebookLM
Save chat history before starting a new topic
The note will include timestamps and message attribution (User/NotebookLM).
Inputs: title, session_id, notebook_url. Returns: data, error, success
note_to_sourceA
Convert a note to a source document in NotebookLM.
This feature allows you to convert an existing note into a source, making the note content available for RAG queries and research.
The method:
Finds the note by title in the Studio panel
Attempts to use NotebookLM's native "Convert to source" feature if available
Falls back to extracting note content and creating a text source if not
Use this when you want your note content to be included in NotebookLM's knowledge base for answering questions.
Inputs: note_title (required), session_id, notebook_url. Returns: data, error, success
rename_sourceA
Rename one source inside a notebook. RPC-backed (no browser). Identify the source by source_id (see list_sources) or by source_name — an ambiguous name is refused rather than guessed.
Inputs: title (required), source_id, notebook_id, source_name, +1 more. Returns: data, error, success
research_sourcesA
Discover web sources for a notebook via NotebookLM Fast Research. RPC-backed. Returns the found sources; set import: true to also add them to the notebook.
Inputs: query (required), import, notebook_id, notebook_url. Returns: data, error, success
retry_contentA
Retry a Studio generation that failed, keeping the same content id. RPC-backed. Prefer this over deleting and regenerating: that mints a new id and invalidates every reference you were holding. The artifact goes back to generating; poll list_content for the outcome. A retry can fail again on Google’s side.
Inputs: content_id (required), notebook_id, notebook_url. Returns: data, error, success
revise_slideA
Revise one slide of an existing slide deck from a prompt, instead of regenerating the whole deck. RPC-backed. slide_index is zero-based. The call returns as soon as the revision is accepted; poll list_content for the result.
Inputs: prompt (required), artifact_id (required), slide_index (required), notebook_id, +1 more. Returns: data, error, success
search_passagesA
Find the passages in a notebook’s sources that match a query, ranked best first. RPC-backed (no browser). This is retrieval, not an answer: nothing is generated, no generation quota is spent, and you get the indexed text with its offsets. Prefer this over ask_question when you want the evidence rather than the prose, and when you intend to reason over the passages yourself.
Inputs: query (required), limit, source_ids, notebook_id, +2 more. Returns: data, error, success
server_cleanupADestructive
ULTRATHINK Deep Cleanup - Scans entire system for ALL NotebookLM MCP data files across 8 categories. Always runs in deep mode, shows categorized preview before deletion.
⚠️ CRITICAL: Close ALL Chrome/Chromium instances BEFORE running this tool! Open browsers can prevent cleanup and cause issues.
Categories scanned:
Legacy Installation (notebooklm-mcp-nodejs) - Old paths with -nodejs suffix
Current Installation (notebooklm-mcp) - Active data, browser profiles, library
NPM/NPX Cache - Cached installations from npx
Claude CLI MCP Logs - MCP server logs from Claude CLI
Temporary Backups - Backup directories in system temp
Claude Projects Cache - Project-specific cache (optional)
Editor Logs (Cursor/VSCode) - MCP logs from code editors (optional)
Trash Files - Deleted notebooklm files in system trash (optional)
Works cross-platform (Linux, Windows, macOS). Safe by design: shows detailed preview before deletion, requires explicit confirmation.
LIBRARY PRESERVATION: Set preserve_library=true to keep your notebook library.json file while cleaning everything else.
RECOMMENDED WORKFLOW for fresh start:
Ask user to close ALL Chrome/Chromium instances
Run cleanup_data(confirm=false, preserve_library=true) to preview
Run cleanup_data(confirm=true, preserve_library=true) to execute
Run setup_auth or re_auth for fresh browser session
Use cases: Clean reinstall, troubleshooting auth issues, removing all traces before uninstall, cleaning old browser sessions and installation data.
Inputs: confirm (required), preserve_library. Returns: data, error, success
server_healthARead-onlyIdempotent
Get server health status including authentication state, active sessions, and configuration. Use this to verify the server is ready before starting research workflows.
If authenticated=false and having persistent issues: Consider running cleanup_data(preserve_library=true) + setup_auth for fresh start with clean browser session.
Inputs: no named parameters. Returns: data, error, success
session_closeADestructiveIdempotent
Close a specific session by session ID. Ask before closing if the user might still need it.
Inputs: session_id (required). Returns: data, error, success
session_listARead-onlyIdempotent
List all active sessions with stats (age, message count, last activity). Use to continue the most relevant session instead of starting from scratch.
Inputs: no named parameters. Returns: data, error, success
session_resetADestructiveIdempotent
Reset a session's chat history (keep same session ID). Use for a clean slate when the task changes; ask the user before resetting.
Inputs: session_id (required). Returns: data, error, success
source_addA
Add a source (document, URL, text, YouTube video) to the current NotebookLM notebook.
Supported source types:
file: Upload a local file (PDF, DOCX, TXT, etc.). Audio (MP3, M4A…) is transcribed and images (JPG, PNG…) are read, so a voice memo or a photo of a whiteboard becomes a queryable source.
url: Add a web page URL
text: Paste text content directly
youtube: Add a YouTube video URL
google_drive: Add a Google Drive document link
The source will be processed and indexed for use in conversations.
Inputs: source_type (required), url, text, title, +3 more. Returns: data, error, success
source_copyA
Copy some of a notebook’s sources into another existing notebook. RPC-backed. Returns, for each source, its original id and the id of the copy. The target must be named explicitly. Only from a notebook you own (not one shared with you or public). Not idempotent: a failure is never retried automatically.
Inputs: source_ids (required), notebook_id, notebook_url, target_notebook_id, +1 more. Returns: data, error, success
source_deleteADestructive
Delete a source from the current NotebookLM notebook.
You can identify the source to delete by either:
source_id: The unique identifier of the source
source_name: The name/title of the source (partial match supported)
Use list_content first to see available sources and their IDs/names.
WARNING: This action is irreversible. The source will be permanently removed from the notebook.
Inputs: source_id, session_id, source_name, notebook_url. Returns: data, error, success
source_listARead-onlyIdempotent
List the sources of a NotebookLM notebook, with their IDs and titles.
Use this to get the source_id that read_source and delete_source expect. RPC-backed (no browser).
Inputs: notebook_id, notebook_url. Returns: data, error, success
source_readARead-onlyIdempotent
Read a source’s full indexed content — the exact text NotebookLM reasons over, which the web UI only ever shows in fragments.
Use it to quote a source verbatim, to check what was actually ingested from a PDF or web page, or to feed the raw material to another tool. Identify the source by source_id (from list_sources) or by source_name (partial match).
Long sources are paginated by default: you get the first 20,000 characters plus totalChars, nextCursor and a continue instruction telling you exactly how to ask for the rest. Pass cursor to continue, or paginate: false to take the whole document in one call. RPC-backed (no browser).
Inputs: cursor, format, paginate, max_chars, +4 more. Returns: data, error, success
vault_batchA
Run a list of questions against a notebook and persist each answer to disk as two artifacts: {slug}.md (markdown with YAML frontmatter, answer body and cited source excerpts) and {slug}.json (structured payload conforming to the nblm-answer-v1 schema). Designed for one-shot ingestion of a notebook into a searchable markdown vault (e.g. for indexing with RTFM) — every answer keeps titles + highlighted excerpts, so repeat queries no longer need to round-trip through NotebookLM.
Reuses the same browser/session as ask_question — no HTTP server required. Pass sleep_between_ms (1500–3000ms) for batches above ~20 questions to avoid hammering NotebookLM.
Returns per-question file paths, success flags, citation counts and the resolved session id. See the RTFM integration guide for the recommended workflow.
Inputs: questions (required), vault_dir (required), session_id, notebook_id, +4 more. Returns: data, error, success
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 56 tools
Many clusters overlap heavily: library_list vs notebook_list; library_add vs notebook_create vs library_discover; source_list/content_list/note_list; source_delete/content_delete/notebook_delete; content_generate vs generate_study_aid vs generate_mind_map; notebook_ask vs search_passages vs vault_batch. Descriptions also reference tool names that do not exist in this set (get_health, ask_question, add_notebook, list_sources, cleanup_data, setup_auth), which will actively mislead an agent choosing tools.
All names are snake_case, but the ordering convention is mixed: noun_verb (source_delete, content_generate, notebook_copy) alongside verb_noun (delete_chat_history, get_source_guide, generate_mind_map). Some names are vague or omit the domain noun entirely (vault_batch, manage_labels, share_notebook), though most remain readable.
56 tools is an extreme overshoot for a single NotebookLM integration and spans library management, browser auth, cleanup, sessions, sources, Studio artifacts, notes, research, and usage. Many operations could be consolidated or moved behind a smaller set of parameterized tools.
The surface is unusually comprehensive: notebook lifecycle, source ingestion/reading/deletion/copying, Studio generation/export/download, notes, chat, research, labels, sharing, auth, cleanup, and usage are all represented. Minor gaps remain, such as no direct NotebookLM-side notebook rename and several Studio content types explicitly marked as not implemented.
Maintenance
Related MCP Connectors
n8n MCP — query your own n8n instance (BYO).
MCP-native notes and memory for ChatGPT, Claude, and other AI tools.
Private persistent memory for Claude, ChatGPT & Gemini via MCP - semantic search, zero-code setup.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- AlicenseAqualityBmaintenanceProvides CLI and MCP server to programmatically access Google NotebookLM, enabling AI assistants to create notebooks, add sources, generate podcasts, and more, with support for both personal and enterprise accounts.41MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that lets CLI agents (Claude, Codex, Cursor) chat directly with Google NotebookLM for zero-hallucination answers based on user's own notebooks.MIT
- AlicenseAqualityDmaintenanceA thin MCP wrapper around the unofficial Google NotebookLM Python client, enabling notebook management, source handling, chat, artifact generation, deep research, and sharing via MCP tools.39MIT
- AlicenseNot gradedqualityCmaintenanceEnables interaction with Google NotebookLM through a unified CLI and MCP server, featuring automatic multi-browser authentication and support for notebook queries, source management, notes, and audio generation.MIT