Skip to main content
Glama
NotebookLM MCP Server
by Robiton

NotebookLM CLI & MCP Server — Enterprise + Personal

NotebookLM MCP Header

Python License Fork of

This is an enterprise-focused fork of jacob-bd/notebooklm-mcp-cli. It adds full support for NotebookLM Enterprise (notebooklm.cloud.google.com) via the official Discovery Engine REST API, while keeping all personal-mode features intact. If you only use personal NotebookLM, the upstream repo is the right choice. If you have a Google Workspace enterprise account, you're in the right place.

What this fork adds over upstream

Addition

Details

Enterprise REST API client

Official Discovery Engine API — not reverse-engineered batchexecute

GCP OAuth2 authentication

gcloud auth login instead of browser cookies

configure_mode MCP tool

Switch personal ↔ enterprise from within Claude, with auth pre-checks

Paywall detection

URL sources checked for login/subscription walls before adding

Per-URL batch fault isolation

One bad URL in a batch no longer fails the entire batch

Standalone Podcast API

Generate podcasts from raw text — no notebook required

Persistent config

nlm config set enterprise.mode enterprise — no env var editing each session

All personal-mode features (chat, video, reports, flashcards, research, sharing, etc.) are fully preserved.

Programmatic access to Google NotebookLM — via command-line interface (CLI) or Model Context Protocol (MCP) server. Supports both Personal and Enterprise accounts.

📺 Watch the Demos

Note: The demos below are from the upstream project (jacob-bd/notebooklm-mcp-cli) and show personal mode features. All commands and MCP tools work identically in this fork — enterprise mode adds on top of everything shown here.

Latest

Codex Setup + Cinematic Video & Slides

Latest

MCP Demos

General Overview

Claude Desktop

Perplexity Desktop

MCP Super Assistant

General

Claude

Perplexity

MCP SuperAssistant

CLI Demos

CLI Overview

CLI, MCP & Skills

Setup, Doctor & mcpb

Infographics Support

CLI Overview

CLI, MCP & Skills

Setup, Doctor & mcpb

Infographics

Two Ways to Use

🖥️ Command-Line Interface (CLI)

Use nlm directly in your terminal for scripting, automation, or interactive use:

nlm notebook list                              # List all notebooks
nlm notebook create "Research Project"         # Create a notebook
nlm source add <notebook> --url "https://..."  # Add sources
nlm audio create <notebook> --confirm          # Generate podcast
nlm download audio <notebook> <artifact-id>    # Download audio file
nlm share public <notebook>                    # Enable public link

Run nlm --ai for comprehensive AI-assistant documentation.

🤖 MCP Server (for AI Agents)

Connect AI assistants (Claude, Gemini, Cursor, etc.) to NotebookLM:

# Automatic setup — picks the right config for each tool
nlm setup add claude-code
nlm setup add gemini
nlm setup add github-copilot
nlm setup add cursor
nlm setup add cline
nlm setup add antigravity

# Generate JSON config for any other tool
nlm setup add json

Then use natural language: "Create a notebook about quantum computing and generate a podcast"

Related MCP server: notebooklm-mcp-2026

Features

Capability

CLI Command

MCP Tool

List notebooks

nlm notebook list

notebook_list

Create notebook

nlm notebook create

notebook_create

Add Sources (URL, Text, Drive, File)

nlm source add

source_add

Query notebook (persists to web UI)

nlm notebook query

notebook_query

Create Studio Content (Audio, Video, etc.)

nlm studio create

studio_create

Revise slide decks

nlm slides revise

studio_revise

Download artifacts

nlm download <type>

download_artifact

Web/Drive research

nlm research start

research_start

Share notebook

nlm share public/invite

notebook_share_*

Sync Drive sources

nlm source sync

source_sync_drive

Batch operations

nlm batch query/create/delete

batch

Cross-notebook query

nlm cross query

cross_notebook_query

Pipelines (multi-step workflows)

nlm pipeline run/list

pipeline

Tag & smart select

nlm tag add/list/select

tag

Configure AI tools

nlm setup add/remove/list

—

Install AI Skills

nlm skill install/update

—

Diagnose issues

nlm doctor

—

📚 More Documentation:

  • Getting Started — Install, login, agent setup, and migration from another NotebookLM MCP

  • CLI Guide — Complete command reference

  • MCP Guide — All 35 MCP tools with examples

  • Authentication — Setup and troubleshooting

  • Remote MCP — Web/mobile connector feasibility, security, and authentication limitations

  • API Reference — Internal API docs for contributors

Important Disclaimer

This MCP and CLI use internal APIs that:

  • Are undocumented and may change without notice

  • Require cookie extraction from your browser (I have a tool for that!)

Use at your own risk for personal/experimental purposes.

Installation

🆕 Claude Desktop users: Download the extension (.mcpb file) → double-click → done! One-click install, no config needed.

Install from PyPI. This single package includes both the CLI and MCP server:

uv tool install notebooklm-enterprise-mcp

Using uvx (Run Without Install)

uvx --from notebooklm-enterprise-mcp nlm --help
uvx --from notebooklm-enterprise-mcp notebooklm-mcp

Using pip

pip install notebooklm-enterprise-mcp

Using pipx

pipx install notebooklm-enterprise-mcp

After installation, you get:

  • nlm — Command-line interface

  • notebooklm-mcp — MCP server for AI assistants

# Clone the repository
git clone https://github.com/Robiton/notebooklm-mcp-cli.git
cd notebooklm-mcp

# Install with uv
uv tool install .

Upgrading

# Using uv
uv tool upgrade notebooklm-enterprise-mcp

# Using pip
pip install --upgrade notebooklm-enterprise-mcp

# Using pipx
pipx upgrade notebooklm-enterprise-mcp

After upgrading, restart your AI tool to reconnect to the updated MCP server:

  • Claude Code: Restart the application, or use /mcp to reconnect

  • Cursor: Restart the application

  • Gemini CLI: Restart the CLI session

Switching from Upstream (jacob-bd/notebooklm-mcp-cli)

If you were using the upstream package and want to switch to this fork for enterprise support:

Step 1: Uninstall the upstream package

uv tool uninstall notebooklm-mcp-cli
# or: pip uninstall notebooklm-mcp-cli

Step 2: Install this fork's package

uv tool install notebooklm-enterprise-mcp

Step 3: Verify

uv tool list | grep notebooklm
# Should show: notebooklm-enterprise-mcp v1.0.0
#                - nlm
#                - notebooklm-mcp

Step 4: Re-authenticate (if needed)

Your existing cookies from the upstream package should still work. If you hit auth errors:

nlm login

MCP configuration doesn't change — the executable is still called notebooklm-mcp, so your Claude Code, Cursor, or other tool configs need no edits.

Getting Started

If you are setting up the tool for the first time — or migrating from a browser-based NotebookLM MCP — see the Getting Started Guide. It covers install, login, agent registration, and a step-by-step migration path that avoids the "two NotebookLM servers registered" trap.

Uninstalling

To completely remove the MCP:

# Using uv
uv tool uninstall notebooklm-enterprise-mcp

# Using pip
pip uninstall notebooklm-enterprise-mcp

# Using pipx
pipx uninstall notebooklm-enterprise-mcp

# Remove cached auth tokens and data (optional)
rm -rf ~/.notebooklm-mcp-cli

Also remove from your AI tools:

nlm setup remove claude-code
nlm setup remove cursor
# ... or any configured tool

Why This Fork?

The upstream project targets personal NotebookLM accounts only. Enterprise NotebookLM (notebooklm.cloud.google.com) uses a completely different authentication system (GCP OAuth2) and a separate official REST API — it's not just a different URL.

This fork adds:

  • Enterprise REST API client — official Discovery Engine API, not reverse-engineered batchexecute

  • Persistent config — nlm config set enterprise.mode enterprise persists across restarts (no env var editing)

  • configure_mode MCP tool — switch modes from within Claude with auth pre-checks

  • Paywall detection — URL sources are checked for login/subscription walls before adding

  • Per-URL bulk results — one bad URL in a batch doesn't fail the whole batch

  • Standalone Podcast API — generate podcasts from raw text, no notebook needed

The enterprise REST API (v1alpha) covers notebooks, sources, and audio. Chat, video, reports, and other features remain personal-only — they have no documented REST endpoints. The hope is that Google promotes the API to v1 stable and expands coverage over time.

See docs/AUTHENTICATION.md for full enterprise setup instructions.


Enterprise Mode

If you use NotebookLM Enterprise (notebooklm.cloud.google.com), configure enterprise mode:

Via CLI

nlm config set enterprise.mode enterprise
nlm config set enterprise.project_id YOUR_PROJECT_NUMBER
nlm config set enterprise.location global    # or "us" or "eu"

Via MCP (Claude Desktop)

Ask Claude to call:

configure_mode(mode="enterprise", project_id="YOUR_PROJECT_NUMBER", location="global")

Enterprise Authentication

Enterprise uses GCP OAuth2 instead of browser cookies:

gcloud auth login

Switch Back to Personal

nlm config set enterprise.mode personal

Enterprise Feature Support

Feature

Personal

Enterprise

Notebooks (list/create/get/delete)

All

All

Sources (add URL/text/YouTube/Drive/file)

All

All

Audio Overview (podcast)

Yes

Yes

Standalone Podcast API

No

Yes

Sharing

Public + email

Email only (org-scoped)

Chat/Query

Yes

Not in REST API

Video, Reports, Flashcards, etc.

Yes

Not in REST API

Environment variables (NOTEBOOKLM_MODE, NOTEBOOKLM_PROJECT_ID, NOTEBOOKLM_LOCATION) override config.toml when set.

Paywall / Login-Required URLs

When adding URL sources, the MCP checks if the URL is behind a paywall or login wall. If your organisation hosts content on an internal domain or a subscription site you have access to, add it to your approved list to skip the check:

# Approve a single domain
nlm config set sources.approved_domains '["yourcompany.com"]'

# Approve multiple domains
nlm config set sources.approved_domains '["yourcompany.com", "ft.com", "wsj.com"]'

Or in the MCP, call source_add with skip_paywall_check=True to bypass for a single URL.

Authentication

Before using the CLI or MCP, you need to authenticate with NotebookLM:

# Auto mode: launches your browser, you log in, cookies extracted automatically
nlm login

# Check if already authenticated
nlm login --check

# Use a named profile (for multiple Google accounts)
nlm login --profile work
nlm login --profile personal

# Manual mode: import cookies from a file
nlm login --manual --file cookies.txt

# External CDP provider (e.g., OpenClaw-managed browser)
nlm login --provider openclaw --cdp-url http://127.0.0.1:18800

Profile management:

nlm login --check                    # Show current auth status
nlm login switch <profile>           # Switch the default profile
nlm login profile list               # List all profiles with email addresses
nlm login profile delete <profile>   # Delete a profile
nlm login profile rename <old> <new> # Rename a profile

Each profile gets its own isolated browser session, so you can be logged into multiple Google accounts simultaneously.

Standalone Auth Tool

If you only need the MCP server (not the CLI):

nlm login              # Auto mode (launches browser)
nlm login --manual     # Manual file mode

How it works: Auto mode launches a dedicated browser profile (supports Chrome, Arc, Brave, Edge, Chromium, and more), you log in to Google, and cookies are extracted automatically. Your login persists for future auth refreshes.

Prefer a specific browser? Set it with nlm config set auth.browser chromium (or brave, arc, edge, chrome, etc.). Falls back to auto-detection if the preferred browser is not found.

For detailed instructions and troubleshooting, see docs/AUTHENTICATION.md.

MCP Configuration

⚠️ Context Window Warning: This MCP provides 39 tools. Disable it when not using NotebookLM to preserve context. In Claude Code: @notebooklm-mcp to toggle.

Use nlm setup to automatically configure the MCP server for your AI tools — no manual JSON editing required:

# Add to any supported tool
nlm setup add claude-code
nlm setup add claude-desktop
nlm setup add gemini
nlm setup add github-copilot
nlm setup add cursor
nlm setup add windsurf

# Generate JSON config for any other tool
nlm setup add json

# Check which tools are configured
nlm setup list

# Diagnose installation & auth issues
nlm doctor

Install AI Skills (Optional)

Install the NotebookLM expert guide for your AI assistant to help it use the tools effectively. Supported for Cline, Antigravity, OpenClaw, Codex, OpenCode, Claude Code, and Gemini CLI.

# Install skill files
nlm skill install cline
nlm skill install openclaw
nlm skill install codex
nlm skill install antigravity

# Update skills
nlm skill update

Remove from a tool

nlm setup remove claude-code

Using uvx (No Install Required)

If you don't want to install the package, you can use uvx to run on-the-fly:

# Run CLI commands directly
uvx --from notebooklm-enterprise-mcp nlm setup add cursor
uvx --from notebooklm-enterprise-mcp nlm login

For tools that use JSON config, point them to uvx:

{
  "mcpServers": {
    "notebooklm-mcp": {
      "command": "uvx",
      "args": ["--from", "notebooklm-enterprise-mcp", "notebooklm-mcp"]
    }
  }
}

Tip: Run nlm setup add json for an interactive wizard that generates the right JSON snippet for your tool.

Claude Code / Gemini CLI support adding MCP servers via their own CLI:

claude mcp add --scope user notebooklm-mcp notebooklm-mcp
gemini mcp add --scope user notebooklm-mcp notebooklm-mcp

Cursor / Windsurf resolve commands from your PATH, so the command name is enough:

{
  "mcpServers": {
    "notebooklm-mcp": {
      "command": "notebooklm-mcp"
    }
  }
}

Tool

Config Location

Cursor

~/.cursor/mcp.json

Windsurf

~/.codeium/windsurf/mcp_config.json

GitHub Copilot (VS Code workspace) uses .vscode/mcp.json with a top-level servers key:

{
  "servers": {
    "notebooklm-mcp": {
      "command": "notebooklm-mcp",
      "args": []
    }
  }
}

Claude Desktop may not resolve PATH — use the full path to the binary:

{
  "mcpServers": {
    "notebooklm-mcp": {
      "command": "/full/path/to/notebooklm-mcp"
    }
  }
}

Find your path with: which notebooklm-mcp

Tool

Config Location

Claude Desktop

~/Library/Application Support/Claude/claude_desktop_config.json

GitHub Copilot

.vscode/mcp.json

📚 Full configuration details: MCP Guide — Server options, environment variables, HTTP transport, and context window management. For Claude web/mobile and public deployment, read Remote MCP Deployment first.

What You Can Do

Simply chat with your AI tool (Claude Code, Cursor, Gemini CLI) using natural language. Here are some examples:

Research & Discovery

  • "List all my NotebookLM notebooks"

  • "Create a new notebook called 'AI Strategy Research'"

  • "Start web research on 'enterprise AI ROI metrics' and show me what sources it finds"

  • "Do a deep research on 'cloud marketplace trends' and import the top 10 sources"

  • "Search my Google Drive for documents about 'product roadmap' and create a notebook"

Adding Content

  • "Add this URL to my notebook: https://example.com/article"

  • "Add this YouTube video about Kubernetes to the notebook"

  • "Add my meeting notes as a text source to this notebook"

  • "Import this Google Doc into my research notebook"

AI-Powered Analysis

  • "What are the key findings in this notebook?"

  • "Summarize the main arguments across all these sources"

  • "What does this source say about security best practices?"

  • "Get an AI summary of what this notebook is about"

  • "Configure the chat to use a learning guide style with longer responses"

(All queries sent from CLI or MCP automatically persist in your NotebookLM web UI chat history!)

Content Generation

  • "Create an audio podcast overview of this notebook in deep dive format"

  • "Generate a video explainer with classic visual style"

  • "Make a short vertical video overview of the key idea"

  • "Make a briefing doc from these sources"

  • "Create flashcards for studying, medium difficulty"

  • "Generate an infographic in landscape orientation with professional style"

  • "Build a mind map from my research sources"

  • "Create a slide deck presentation from this notebook"

Smart Management

  • "Check which Google Drive sources are out of date and sync them"

  • "Show me all the sources in this notebook with their freshness status"

  • "Delete this source from the notebook"

  • "Check the status of my audio overview generation"

Sharing & Collaboration

  • "Show me the sharing settings for this notebook"

  • "Make this notebook public so anyone with the link can view it"

  • "Disable public access to this notebook"

  • "Invite user@example.com as an editor to this notebook"

  • "Add a viewer to my research notebook"

Pro tip: After creating studio content (audio, video, reports, etc.), poll the status to get download URLs when generation completes.

Authentication Lifecycle

Component

Duration

Refresh

Cookies

~2-4 weeks

Auto-refresh via headless browser (if profile saved)

CSRF Token

~minutes

Auto-refreshed on every request failure

Session ID

Per MCP session

Auto-extracted on MCP start

v1.0.0+: The server now automatically handles token expiration:

  1. Refreshes CSRF tokens immediately when expired

  2. Reloads cookies from disk if updated externally

  3. Runs headless browser auth if profile has saved login

You can also call refresh_auth() to explicitly reload tokens.

If automatic refresh fails (Google login fully expired), run nlm login again.

Troubleshooting

uv tool upgrade Not Installing Latest Version

Symptoms:

  • Running uv tool upgrade notebooklm-enterprise-mcp installs an older version than expected

  • uv cache clean doesn't fix the issue

Why this happens: uv tool upgrade respects version constraints from your original installation. If you initially installed an older version or with a constraint, upgrade stays within those bounds by design.

Fix — Force reinstall:

uv tool install --force notebooklm-enterprise-mcp

This bypasses any cached constraints and installs the absolute latest version from PyPI.

Verify:

uv tool list | grep notebooklm
# Should show: notebooklm-enterprise-mcp v1.0.0 (or latest)

Limitations

  • Rate limits: Free tier has ~50 queries/day

  • No official support: API may change without notice

  • Cookie expiration: Need to re-extract cookies every few weeks

Reporting Issues

Use the GitHub Issues tab — you'll be prompted to pick the right template:

Template

Use when

Bug — Enterprise

Something broken in enterprise mode (GCP, Discovery Engine API)

Bug — Personal

Something broken in personal mode that's specific to this fork

Feature Request

New capability you'd like to see

Question

Setup help, usage questions, config issues

Personal mode bugs that also exist in the upstream project should be filed at jacob-bd/notebooklm-mcp-cli first — fixes accepted there get cherry-picked here automatically.

Contributing

See CONTRIBUTING.md for setup instructions, PR process, and how to add new features.

A Note on This Fork

This fork started as an internal tool to fill a real gap: NotebookLM Enterprise had no programmatic access, and the upstream project (which is excellent) is scoped to personal accounts only. The enterprise implementation was built with AI assistance — I'm not a professional Python developer — so if you see something that could be done better, PRs are genuinely welcome.

The upstream project's original "vibe coding" spirit applies here too: the goal was to solve a problem, not to write a textbook. The code works, passes tests, and is production-stable enough for daily use. But experienced developers will likely see room for improvement, and that input is valuable.

See CONTRIBUTING.md for how to get involved — especially if you have enterprise NotebookLM access and can test end-to-end.

Credits

Special thanks to:

  • Le Anh Tuan (@latuannetnam) for contributing the HTTP transport, debug logging system, and performance optimizations.

  • David Szabo-Pele (@davidszp) for the source_get_content tool and Linux auth fixes.

  • saitrogen (@saitrogen) for the research polling query fallback fix.

  • devnull03 (@devnull03) for multi-browser CDP authentication support (Arc, Brave, Edge, Chromium, Vivaldi, Opera).

  • VooDisss (@VooDisss) for multi-browser authentication improvements.

  • codepiano (@codepiano) for the configurable DevTools timeout for the auth CLI.

  • Tony Hansmann (@997unix) for contributing the nlm setup and nlm doctor commands and CLI Guide documentation.

  • Fabiana Furtado (@fabianafurtadoff) for batch operations, cross-notebook query, pipelines, and smart select/tagging (PR #90).

  • Amy-Ra-lph (@Amy-Ra-lph) for security hardening: TOCTOU-safe credential storage, sensitive cookie redaction from debug logs, and pinning all CI actions to full commit SHAs (PRs #205–207).

  • Kyle Brodeur (@kylebrodeur) for WSL2 authentication support with Windows Chrome integration (PR #138).

  • Robiton (@Robiton) for enterprise NotebookLM support via configurable base URL (PR #114).

  • pjeby (@pjeby) for connection pooling and fast startup improvements (PR #54).

  • beausea (@beausea) for making the interface language configurable via the NOTEBOOKLM_HL environment variable (PR #59).

  • JumpLao (@JumpLao) for extended audio, video, and image format support (PR #82).

  • cbruyndoncx (@cbruyndoncx) for including cited_text passages in query output (PR #81).

  • zxyasfas (@zxyasfas) for cited-only research import (PR #188).

  • Serdar Akın (@SERDAR-AKIN) for the multi-probe AuthHealthChecker that fixes false "stale" reports for semi-stale cookies (PR #219).

License

MIT License

Available Tools

41 tools
batchA

Perform batch operations across multiple notebooks.

Actions:

  • query: Query multiple notebooks with the same question

  • add_source: Add the same source URL to multiple notebooks

  • create: Create multiple notebooks at once

  • delete: Delete multiple notebooks (IRREVERSIBLE, requires confirm=True)

  • studio: Generate studio artifacts across multiple notebooks

Args: action: Operation to perform (query, add_source, create, delete, studio) query: Question to ask (for action=query) source_url: URL to add (for action=add_source) titles: Comma-separated notebook titles (for action=create) artifact_type: Artifact type (for action=studio): audio, video, report, etc. notebook_names: Comma-separated notebook names or IDs tags: Comma-separated tags to select notebooks all: Apply to ALL notebooks confirm: Must be True for delete action

Inputs: action (required), query, source_url, titles, +5 more. Returns: object

chat_configureB

Configure notebook chat settings.

Args: notebook_id: Notebook UUID goal: default|learning_guide|custom custom_prompt: Required when goal=custom (max 10000 chars) response_length: default|longer|shorter

Inputs: notebook_id (required), goal, custom_prompt, response_length. Returns: object

configure_modeA

Configure NotebookLM mode (personal or enterprise).

IMPORTANT: Enterprise and personal use SEPARATE authentication.

  • Enterprise: requires gcloud auth login (GCP OAuth2)

  • Personal: requires nlm login (browser cookie auth) Switching modes without the correct auth will cause 400/401 errors. Always confirm the user has authenticated for the target mode before switching.

Args: mode: "personal" or "enterprise" project_id: GCP project number (required for enterprise, found in NotebookLM URL) location: GCP location - "global", "us", or "eu" (default: "global")

Returns: Dictionary with status, configuration, and auth requirements.

Inputs: mode, project_id, location. Returns: object

cross_notebook_queryA

Query multiple notebooks and get aggregated answers with per-notebook citations.

Specify notebooks by name, by tags, or use all=True for all notebooks.

Args: query: Question to ask across notebooks notebook_names: Comma-separated notebook names or IDs (e.g. "AI Research, Dev Tools") tags: Comma-separated tags to select notebooks (e.g. "ai,mcp") all: Query ALL notebooks (use with caution — rate limits apply)

Inputs: query (required), notebook_names, tags, all. Returns: object

download_artifactA

Download any NotebookLM artifact to a file.

Unified download tool replacing 9 separate download tools. Supports all artifact types: audio, video, report, mind_map, slide_deck, infographic, data_table, quiz, flashcards.

Args: notebook_id: Notebook UUID artifact_type: Type of artifact to download: - audio: Audio Overview (MP4/MP3) - video: Video Overview (MP4) - report: Report (Markdown) - mind_map: Mind Map (JSON) - slide_deck: Slide Deck (PDF or PPTX) - infographic: Infographic (PNG) - data_table: Data Table (CSV) - quiz: Quiz (json|markdown|html) - flashcards: Flashcards (json|markdown|html) output_path: Path to save the file artifact_id: Optional specific artifact ID (uses latest if not provided) output_format: For quiz/flashcards only: json|markdown|html (default: json) slide_deck_format: For slide_deck only: pdf (default) or pptx

Returns: dict with status and saved file path

Example: download_artifact(notebook_id="abc123", artifact_type="audio", output_path="podcast.mp3") download_artifact(notebook_id="abc123", artifact_type="quiz", output_path="quiz.html", output_format="html") download_artifact(notebook_id="abc123", artifact_type="slide_deck", output_path="slides.pptx", slide_deck_format="pptx")

Inputs: notebook_id (required), artifact_type (required), output_path (required), artifact_id, +2 more. Returns: object

export_artifactA

Export a NotebookLM artifact to Google Docs or Sheets.

Supports:

  • Data Tables → Google Sheets

  • Reports (Briefing Doc, Study Guide, Blog Post) → Google Docs

Args: notebook_id: Notebook UUID artifact_id: Artifact UUID to export export_type: "docs" or "sheets" title: Title for exported document (optional)

Returns: URL to the created Google Doc/Sheet

Inputs: notebook_id (required), artifact_id (required), export_type (required), title. Returns: object

noteA

Manage notes in a notebook. Unified tool for all note operations.

Supports: create, list, update, delete

Args: notebook_id: Notebook UUID action: Operation to perform: - create: Create a new note - list: List all notes in notebook - update: Update an existing note - delete: Delete a note permanently (requires confirm=True) note_id: Note UUID (required for update/delete) content: Note content (required for create, optional for update) title: Note title (optional for create/update) confirm: Must be True for delete action

Returns: Action-specific response with status

Example: note(notebook_id="abc", action="list") note(notebook_id="abc", action="create", content="My note", title="Title") note(notebook_id="abc", action="update", note_id="xyz", content="Updated") note(notebook_id="abc", action="delete", note_id="xyz", confirm=True)

Inputs: notebook_id (required), action (required), note_id, content, +2 more. Returns: object

notebook_createB

Create a new notebook.

Args: title: Optional title for the notebook

Inputs: title. Returns: object

notebook_deleteA

Delete notebook permanently. IRREVERSIBLE. Requires confirm=True.

Args: notebook_id: Notebook UUID confirm: Must be True after user approval

Inputs: notebook_id (required), confirm. Returns: object

notebook_describeA

Get AI-generated notebook summary with suggested topics.

Args: notebook_id: Notebook UUID

Returns: summary (markdown), suggested_topics list

Inputs: notebook_id (required). Returns: object

notebook_getC

Get notebook details with sources.

Args: notebook_id: Notebook UUID

Inputs: notebook_id (required). Returns: object

notebook_listB

List all notebooks.

Args: max_results: Maximum number of notebooks to return (default: 100)

Inputs: max_results. Returns: object

notebook_queryA

Ask AI about EXISTING sources already in notebook. NOT for finding new sources.

Use research_start instead for: deep research, web search, find new sources, Drive search.

Args: notebook_id: Notebook UUID query: Question to ask source_ids: Source IDs to query (default: all) conversation_id: For follow-up questions timeout: Request timeout in seconds (default: from env NOTEBOOKLM_QUERY_TIMEOUT or 120.0)

Inputs: notebook_id (required), query (required), source_ids, conversation_id, +1 more. Returns: object

notebook_query_startA

Start a notebook query asynchronously for large notebooks that may timeout.

Use this instead of notebook_query when querying notebooks with many sources (50+) where the response may take longer than 60 seconds. Returns immediately with a query_id. Poll notebook_query_status with the query_id to get the result.

Workflow: notebook_query_start -> poll notebook_query_status until completed.

Args: notebook_id: Notebook UUID query: Question to ask source_ids: Source IDs to query (default: all) conversation_id: For follow-up questions timeout: Request timeout in seconds (default: from env NOTEBOOKLM_QUERY_TIMEOUT or 120.0)

Inputs: notebook_id (required), query (required), source_ids, conversation_id, +1 more. Returns: object

notebook_query_statusA

Check the status of an async notebook query started with notebook_query_start.

Returns the query result when completed, or current status if still in progress. Poll this tool every few seconds until status is 'completed' or 'error'.

Args: query_id: The query ID returned by notebook_query_start

Inputs: query_id (required). Returns: object

notebook_renameC

Rename a notebook.

Args: notebook_id: Notebook UUID new_title: New title

Inputs: notebook_id (required), new_title (required). Returns: object

notebook_share_batchA

Invite multiple collaborators in a single request.

Args: notebook_id: Notebook UUID recipients: List of dicts, each with 'email' (str) and optional 'role' (str). Role defaults to 'viewer'. Example: [{"email": "a@b.com", "role": "editor"}] confirm: Must be True after user approval

Returns: invited_count, recipients list, and message

Inputs: notebook_id (required), recipients (required), confirm. Returns: object

notebook_share_inviteA

Invite a collaborator by email.

Args: notebook_id: Notebook UUID email: Email address to invite role: "viewer" or "editor" (default: viewer)

Returns: success status

Inputs: notebook_id (required), email (required), role. Returns: object

notebook_share_publicA

Enable or disable public link access.

Args: notebook_id: Notebook UUID is_public: True to enable public link, False to disable (default: True)

Returns: public_link if enabled, None if disabled

Inputs: notebook_id (required), is_public. Returns: object

notebook_share_statusA

Get current sharing settings and collaborators.

Args: notebook_id: Notebook UUID

Returns: is_public, access_level, collaborators list, and public_link if public

Inputs: notebook_id (required). Returns: object

pipelineA

Manage and execute multi-step notebook pipelines.

Actions:

  • run: Execute a pipeline on a notebook

  • list: List all available pipelines (builtin and user-defined)

Args: action: Operation to perform (run, list) notebook_id: Target notebook UUID (required for action=run) pipeline_name: Pipeline name (required for action=run, e.g. "ingest-and-podcast") input_url: URL variable for pipelines that need it (replaces $INPUT_URL)

Inputs: action (required), notebook_id, pipeline_name, input_url. Returns: object

podcast_createA

Generate a standalone podcast from text (Enterprise only, no notebook needed).

Args: text: Text content to turn into a podcast. Can be a single string or a list of strings (each becomes a separate context). title: Optional podcast title description: Optional podcast description focus: Optional topic focus prompt to guide the podcast length: "SHORT" (~4-5 min) or "STANDARD" (~10 min) language: Language code (default: "en")

Returns: Dictionary with operation name for tracking and downloading.

Inputs: text (required), title, description, focus, +2 more. Returns: object

podcast_downloadA

Download a completed standalone podcast.

Args: operation_name: The operation name from podcast_create response output_path: Local file path to save the MP3 (default: ~/Downloads/podcast.mp3)

Returns: Dictionary with the downloaded file path.

Inputs: operation_name (required), output_path. Returns: object

refresh_authA

Reload auth tokens from disk or run headless re-authentication.

Call this after running nlm login to pick up new tokens, or to attempt automatic re-authentication if Chrome profile has saved login.

Returns status indicating if tokens were refreshed successfully.

Inputs: no named parameters. Returns: object

research_importA

Import discovered sources into notebook.

Call after research_status shows status="completed".

Args: notebook_id: Notebook UUID task_id: Research task ID source_indices: Source indices to import (default: all) timeout: Import timeout in seconds (default: 300, increase for large notebooks)

Inputs: notebook_id (required), task_id (required), source_indices, timeout. Returns: object

research_startA

Deep research / fast research: Search web or Google Drive to FIND NEW sources.

Use this for: "deep research on X", "find sources about Y", "search web for Z", "search Drive". Workflow: research_start -> poll research_status -> research_import.

Args: query: What to search for (e.g. "quantum computing advances") source: web|drive (where to search) mode: fast (~30s, ~10 sources) | deep (~5min, ~40 sources, web only) notebook_id: Existing notebook (creates new if not provided) title: Title for new notebook

Inputs: query (required), source, mode, notebook_id, +1 more. Returns: object

research_statusA

Poll research progress. Blocks until complete or timeout.

Args: notebook_id: Notebook UUID poll_interval: Seconds between polls (default: 30) max_wait: Max seconds to wait (default: 300, 0=single poll) compact: If True (default), truncate report and limit sources shown to save tokens. Use compact=False to get full details. task_id: Optional Task ID to poll for a specific research task. query: Optional query text for fallback matching when task_id changes (deep research). Contributed by @saitrogen (PR #15).

Inputs: notebook_id (required), poll_interval, max_wait, compact, +2 more. Returns: object

save_auth_tokensA

Save NotebookLM cookies (FALLBACK method - try nlm login first!).

IMPORTANT FOR AI ASSISTANTS:

  • First, run nlm login via Bash/terminal (automated, preferred)

  • Only use this tool if the automated CLI fails

Args: cookies: Cookie header from Chrome DevTools (only needed if CLI fails) csrf_token: Deprecated - auto-extracted session_id: Deprecated - auto-extracted request_body: Optional - contains CSRF if extracting manually request_url: Optional - contains session ID if extracting manually

Inputs: cookies (required), csrf_token, session_id, request_body, +1 more. Returns: object

server_infoB

Get server version, mode, and auth status.

Returns: dict with version, configuration, and auth status for both modes.

Inputs: no named parameters. Returns: object

source_addA

Add a source to a notebook. Unified tool for all source types.

Supports: url, text, drive, file

For URL sources, a paywall/login check is performed before adding. If the URL appears to require authentication or a subscription, the tool returns a "paywall_detected" status with instructions. Set skip_paywall_check=True to bypass (e.g. the user confirms they have an account on that site).

Args: notebook_id: Notebook UUID source_type: Type of source to add: - url: Web page or YouTube URL - text: Pasted text content - drive: Google Drive document - file: Local file upload (PDF, text, audio) url: URL to add (for source_type=url) urls: List of URLs to add in bulk (for source_type=url, alternative to url) text: Text content to add (for source_type=text) title: Display title (for text sources) file_path: Local file path (for source_type=file) document_id: Google Drive document ID (for source_type=drive) doc_type: Drive doc type: doc|slides|sheets|pdf (for source_type=drive) wait: If True, wait for source processing to complete before returning wait_timeout: Max seconds to wait if wait=True (default 120) skip_paywall_check: If True, skip paywall/login check and add URL anyway

Example: source_add(notebook_id="abc", source_type="url", url="https://example.com") source_add(notebook_id="abc", source_type="url", urls=["https://a.com", "https://b.com"]) source_add(notebook_id="abc", source_type="url", url="https://ft.com/article", skip_paywall_check=True) source_add(notebook_id="abc", source_type="file", file_path="/path/to/doc.pdf", wait=True)

Inputs: notebook_id (required), source_type (required), url, urls, +8 more. Returns: object

source_deleteA

Delete source(s) permanently. IRREVERSIBLE. Requires confirm=True.

Args: source_id: Source UUID to delete (single) source_ids: List of source UUIDs to delete (bulk, alternative to source_id) confirm: Must be True after user approval

Inputs: source_id, source_ids, confirm. Returns: object

source_describeA

Get AI-generated source summary with keyword chips.

Args: source_id: Source UUID

Returns: summary (markdown with bold keywords), keywords list

Inputs: source_id (required). Returns: object

source_get_contentA

Get raw text content of a source (no AI processing).

Returns the original indexed text from PDFs, web pages, pasted text, or YouTube transcripts. Much faster than notebook_query for content export.

Args: source_id: Source UUID

Returns: content (str), title (str), source_type (str), char_count (int)

Inputs: source_id (required). Returns: object

source_list_driveA

List sources with types and Drive freshness status.

Use before source_sync_drive to identify stale sources.

Args: notebook_id: Notebook UUID

Inputs: notebook_id (required). Returns: object

source_renameB

Rename a source in a notebook.

Args: notebook_id: Notebook UUID containing the source source_id: Source UUID to rename new_title: New display title for the source

Inputs: notebook_id (required), source_id (required), new_title (required). Returns: object

source_sync_driveA

Sync Drive sources with latest content. Requires confirm=True.

Call source_list_drive first to identify stale sources.

Args: source_ids: Source UUIDs to sync confirm: Must be True after user approval

Inputs: source_ids (required), confirm. Returns: object

studio_createA

Create any NotebookLM studio artifact. Unified creation tool.

Supports: audio, video, infographic, slide_deck, report, flashcards, quiz, data_table, mind_map

Args: notebook_id: Notebook UUID artifact_type: Type of artifact to create: - audio: Audio Overview (podcast) - video: Video Overview - infographic: Visual infographic - slide_deck: Presentation slides (PDF) - report: Text report (Briefing Doc, Study Guide, etc.) - flashcards: Study flashcards - quiz: Multiple choice quiz - data_table: Structured data table - mind_map: Visual mind map source_ids: Source IDs to use (default: all sources) confirm: Must be True after user approval

Type-specific options:
- audio: audio_format (deep_dive|brief|critique|debate), audio_length (short|default|long)
- video: video_format (explainer|brief|cinematic), visual_style (auto_select|custom|classic|whiteboard|kawaii|anime|watercolor|retro_print|heritage|paper_craft), video_style_prompt
- infographic: orientation (landscape|portrait|square), detail_level (concise|standard|detailed), infographic_style (auto_select|sketch_note|professional|bento_grid|editorial|instructional|bricks|clay|anime|kawaii|scientific)
- slide_deck: slide_format (detailed_deck|presenter_slides), slide_length (short|default)
- report: report_format (Briefing Doc|Study Guide|Blog Post|Create Your Own), custom_prompt
- flashcards: difficulty (easy|medium|hard)
- quiz: question_count (int), difficulty (easy|medium|hard)
- data_table: description (required)
- mind_map: title

Common options:
- language: BCP-47 code (en, es, fr, de, ja). Defaults to NOTEBOOKLM_HL env var or 'en'
- focus_prompt: Optional focus text

Example: studio_create(notebook_id="abc", artifact_type="audio", confirm=True) studio_create(notebook_id="abc", artifact_type="quiz", question_count=5, confirm=True)

Inputs: notebook_id (required), artifact_type (required), source_ids, confirm, +18 more. Returns: object

studio_deleteA

Delete studio artifact. IRREVERSIBLE. Requires confirm=True.

Args: notebook_id: Notebook UUID artifact_id: Artifact UUID (from studio_status) confirm: Must be True after user approval

Inputs: notebook_id (required), artifact_id (required), confirm. Returns: object

studio_reviseA

Revise individual slides in an existing slide deck. Creates a NEW artifact.

Only slide decks support revision. The original artifact is not modified. Poll studio_status after calling to check when the new deck is ready.

Args: notebook_id: Notebook UUID artifact_id: UUID of the existing slide deck to revise (from studio_status) slide_instructions: List of revision instructions, each with: - slide: Slide number (1-based, slide 1 = first slide) - instruction: Text describing the desired change Example: [{"slide": 1, "instruction": "Make the title larger"}] confirm: Must be True after user approval

Example: studio_revise( notebook_id="abc", artifact_id="xyz", slide_instructions=[ {"slide": 1, "instruction": "Make the title larger"}, {"slide": 3, "instruction": "Remove the image"} ], confirm=True )

Inputs: notebook_id (required), artifact_id (required), slide_instructions (required), confirm. Returns: object

studio_statusA

Check studio content generation status and get URLs, or rename an artifact.

Args: notebook_id: Notebook UUID action: Action to perform: - status (default): List all artifacts with their status and URLs - rename: Rename an artifact (requires artifact_id and new_title) - list_types: List all supported artifact types with their options artifact_id: Required for action="rename" - the artifact UUID to rename new_title: Required for action="rename" - the new title for the artifact

Returns: Dictionary with status and results. For action="status": - status: "success" - artifacts: List of artifacts, each containing: - artifact_id: UUID - title: Artifact title - type: audio, video, report, etc. - status: completed, in_progress, failed - url: URL to view/download (if applicable) - custom_instructions: The custom prompt/focus instructions used to generate the artifact (if any) - summary: Counts of total, completed, in_progress

Inputs: notebook_id (required), action, artifact_id, new_title. Returns: object

tagA

Manage notebook tags and find relevant notebooks by tag matching.

Actions:

  • add: Add tags to a notebook for smart selection

  • remove: Remove tags from a notebook

  • list: List all tagged notebooks with their tags

  • select: Find notebooks relevant to a query using tag matching

Args: action: Operation to perform (add, remove, list, select) notebook_id: Notebook UUID (required for add, remove) tags: Comma-separated tags (required for add, remove; e.g. "ai,research,llm") notebook_title: Optional display title (for add) query: Search query (required for select; e.g. "ai mcp" or "ai,mcp")

Inputs: action (required), notebook_id, tags, notebook_title, +1 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 41 tools

    Disambiguation5/5

    Each tool targets a distinct operation or resource. Even with many tools, the boundaries are clear: notebook CRUD, source management, research pipeline, studio artifacts, notes, sharing, tags, etc. No two tools perform the same function.

    Naming Consistency3/5

    Tool names follow different patterns: some use noun_verb (notebook_create, source_add), others verb_noun (download_artifact, export_artifact), and some are single words (note, batch). While subdomains have internal consistency, the overall naming is mixed.

    Tool Count2/5

    41 tools is a very large surface for a single server. Although it covers extensive NotebookLM functionality, the count is high enough to overwhelm agents. Several tools could be consolidated (e.g., async query start/status, podcast tools redundant with studio).

    Completeness5/5

    The toolset covers nearly all NotebookLM features: full CRUD for notebooks, sources, notes, artifacts, research, sharing, tags, configuration, authentication, and batch operations. No obvious gaps in functionality for the domain.

    Maintenance

    ActivityNo data
    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
      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
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that lets CLI agents (Claude, Codex, Cursor) chat directly with Google NotebookLM for zero-hallucination answers based on user's own notebooks.
      4,977 npm
      MIT