notebooklm-py-diet-mcp

Connect your AI agent to Google NotebookLM. Query your notebooks, add sources, generate reports, podcasts, slide decks, and more -- directly from Cursor, Claude Code, or any MCP-compatible client.

Workflow-orientated MCP toolset for IDE level interaction with NotebookLM. Designed as a smart and lightweight MCP server to enable AI code assist-native multi-step workflows (research, generate artifacts, download and convert). Packaged as single tool calls so the agent gets more done with less messing around and without losing capability.

Built on notebooklm-py by Teng Lin.

Unofficial -- Uses undocumented Google APIs via notebooklm-py. Not affiliated with Google. APIs may change without notice.

Need granular control over every SDK method? See the full-fat notebooklm-py-MCP (72 individual tools exposed - designed primarily for testing).

Beyond the SDK

This server is not just a thin wrapper. It adds capabilities that the underlying API does not provide:

• Templated slide generation -- Three bundled design templates (Corporate, Educational, Creative) in templates/slide_styles.md. Pass any template as the instructions parameter to generate_and_download and NotebookLM will follow the specified tone, colour palette, typography, and layout rules. Create your own templates using the same structure.

• PDF / PNG round-trip editing -- pdf_to_png splits a downloaded slide deck (or any PDF) into individual page images that an LLM can review, critique, or annotate. png_to_pdf reassembles edited pages back into a single document. This enables a generate-review-refine loop that is not possible through the NotebookLM interface alone.

• Inline persona control -- ask_question accepts optional persona and response_length parameters, configuring the chat persona in the same call rather than requiring a separate configuration step.

Related MCP server: notebooklm-mcp-server

AI Workflow Tools (14)

MCP Resources

MCP Prompts

Prerequisites

• Python 3.10 or later

• A Google account with access to NotebookLM

• Cursor or another MCP-compatible client

Installation

1. Clone the repository

git clone https://github.com/earlyprototype/notebooklm-py-diet-mcp.git
cd notebooklm-py-diet-mcp

2. Create a virtual environment and install dependencies

python -m venv venv

# Windows (PowerShell)
.\venv\Scripts\Activate.ps1

# macOS / Linux
source venv/bin/activate

pip install -e ".[dev]"

Alternatively, install from requirements.txt:

pip install -r requirements.txt

3. Install Playwright (required for first-time login and auto-reauthentication)

playwright install chromium

4. Authenticate with Google NotebookLM

# Set the account profile directory
# Windows (PowerShell)
$env:NOTEBOOKLM_HOME = "$HOME\.notebooklm-work"

# macOS / Linux
export NOTEBOOKLM_HOME=~/.notebooklm-work

# Login (opens a browser window -- select your Google account)
notebooklm login

# Verify
notebooklm list

Configuration

Cursor

Add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "notebooklm": {
      "command": "<path-to-venv>/python",
      "args": [
        "<path-to-repo>/notebooklm_mcp_server.py"
      ]
    }
  }
}

Replace the placeholder paths with your actual paths. The server manages account profiles internally -- no NOTEBOOKLM_HOME environment variable is needed. Use switch_account and get_account_info to manage profiles at runtime.

Restart Cursor after saving the configuration.

Claude Code

The repository ships a project-scoped .mcp.json, so opening this folder in Claude Code is enough -- it will prompt you to approve the notebooklm server on first launch. It defaults to the venv/ created in step 2; on Windows, or if your interpreter lives elsewhere, point NOTEBOOKLM_MCP_PYTHON at it:

# Windows (PowerShell)
$env:NOTEBOOKLM_MCP_PYTHON = "venv\Scripts\python.exe"

To register the server globally instead (available in every project), pass the absolute path to the virtual environment's interpreter -- not a bare python, which will not have the dependencies installed:

claude mcp add notebooklm -- /path/to/repo/venv/bin/python /path/to/repo/notebooklm_mcp_server.py

Verify with claude mcp list.

HTTP Transport (for MCP Inspector or remote access)

python notebooklm_mcp_server.py --http

Then connect your client to http://localhost:8000/mcp.

Multiple Google Accounts

Each Google account is stored in a separate directory. Set NOTEBOOKLM_HOME to switch between them:

# Authenticate different accounts
NOTEBOOKLM_HOME=~/.notebooklm-work notebooklm login      # Work account
NOTEBOOKLM_HOME=~/.notebooklm notebooklm login            # Personal account
NOTEBOOKLM_HOME=~/.notebooklm-design notebooklm login     # Another account

The get_account_info tool shows the currently active profile and available alternatives. Use switch_account to change at runtime without restarting.

Usage Examples

Once configured, you can interact with NotebookLM directly from your AI agent:

List notebooks:

"List my NotebookLM notebooks"

Query a knowledge base:

"Ask the Strategy notebook: what are our key objectives for 2026?"

Set a persona and ask:

"As a strategy analyst, summarise the key risks in my Research notebook"

Add multiple sources at once:

"Add these URLs to my Research notebook: https://example.com/article1, https://example.com/article2"

Generate and download content:

"Generate a podcast overview for the Project notebook and save it" "Generate a report from the Strategy notebook and download it as PDF" "Create an infographic from the Training notebook"

Research and import:

"Research 'digital fabrication trends' and import the top results into my Research notebook"

Generate a styled slide deck:

"Generate a slide deck for the Strategy notebook using the Corporate template"

Slide Template Demos

The three bundled templates produce distinctly different output from the same workflow. Each example below was generated from a subsection of an innovation literacy training programme.

Corporate

Strategy consulting style -- serif headings, blue accent, data-dense layouts with charts, tables, and evidence callouts.

Educational

Workshop and training style -- warm cream background, teal/amber accents, illustrated concepts, generous whitespace.

Creative

Pitch deck style -- dark backgrounds, lime accent, bold typography, minimal text, visually striking layouts.

See templates/slide_styles.md for the full template definitions or create your own following the same structure.

Project Structure

notebooklm-py-diet-mcp/
  notebooklm_mcp_server.py   # MCP server (14 tools, resources, prompts)
  .mcp.json                   # Project-scoped MCP registration for Claude Code
  pyproject.toml              # Python packaging and tool configuration
  requirements.txt            # Convenience dependency file
  INSTRUCTIONS.md             # Context injected into the LLM when loaded
  LICENSE                     # MIT licence
  README.md                   # This file
  tests/
    conftest.py               # Shared test fixtures and mocks
    test_helpers.py            # Unit tests for helper functions
    test_tools.py              # Mock-based tool tests
    test_lifespan.py           # Server startup scenario tests
  templates/
    slide_styles.md           # Bundled slide design templates
  docs/
    setup.md                  # Detailed setup guide
    demos/selected/           # Curated slide demo images (README gallery)
      demos/corporate/          # Full corporate template example set
      demos/educational/        # Full educational template example set
      demos/creative/           # Full creative template example set

Development

Running tests

pip install -e ".[dev]"
pytest

Linting

ruff check .
ruff format .

INSTRUCTIONS.md

The INSTRUCTIONS.md file is loaded by MCP clients alongside the server and provides the LLM with usage context -- workflow patterns, error handling guidance, and tool conventions. Place it next to notebooklm_mcp_server.py or in the MCP server metadata directory used by your client.

Acknowledgements

This project would not exist without notebooklm-py by Teng Lin and contributors. It provides the complete Python API for Google NotebookLM that this MCP server wraps.

• notebooklm-py on GitHub

• notebooklm-py on PyPI

The MCP server is built using the Model Context Protocol Python SDK by Anthropic.

Licence

MIT -- see LICENSE for details.

Disclaimer

This is an unofficial project. It is not affiliated with, endorsed by, or supported by Google. It relies on undocumented APIs that may change at any time. Use at your own risk. See the notebooklm-py security policy for credential handling guidance.