git:20260227.336a326 to git:20260227.1363d91

---

name: notebooklm

description: Enables interaction with Google NotebookLM for advanced RAG (Retrieval-Augmented Generation) capabilities via the notebooklm-mcp-cli tool. Use when querying project documentation stored in NotebookLM, managing research notebooks and sources, retrieving AI-synthesized information, generating audio podcasts or reports from notebooks, or performing contextual queries against curated knowledge bases. Triggers on "notebooklm", "nlm", "notebook query", "research notebook", "query documentation in notebooklm".

allowed-tools: Bash, Read, Write

---

# NotebookLM Integration

Interact with Google NotebookLM for advanced RAG capabilities — query project documentation, manage research sources, and retrieve AI-synthesized information from notebooks.

## Overview

This skill integrates with the [notebooklm-mcp-cli](https://github.com/jacob-bd/notebooklm-mcp-cli) tool (`nlm` CLI) to provide programmatic access to Google NotebookLM. It enables agents to manage notebooks, add sources, perform contextual queries, and retrieve generated artifacts like audio podcasts or reports.

## When to Use

Use this skill when:

- Querying project documentation stored in Google NotebookLM

- Retrieving AI-synthesized information from notebooks (e.g., summaries, Q&A)

- Managing notebooks: creating, listing, renaming, or deleting

- Adding sources to notebooks: URLs, text, files, YouTube, Google Drive

- Generating studio content: audio podcasts, video explainers, reports, quizzes

- Downloading generated artifacts (audio, video, reports, mind maps)

- Performing research queries across web or Google Drive

- Checking freshness and syncing Google Drive sources

- An agent is tasked with using documentation stored in NotebookLM for implementation

**Trigger phrases:** "query notebooklm", "search notebook", "add source to notebook", "create podcast from notebook", "generate report from notebook", "nlm query"

## Prerequisites

### Installation

```bash

# Install via uv (recommended)

uv tool install notebooklm-mcp-cli

# Or via pip

pip install notebooklm-mcp-cli

# Verify installation

nlm --version

```

### Authentication

```bash

# Login — opens Chrome for cookie extraction

nlm login

# Verify authentication

nlm login --check

# Use named profiles for multiple Google accounts

nlm login --profile work

nlm login --profile personal

nlm login switch work

```

### Diagnostics

```bash

# Run diagnostics if issues occur

nlm doctor

nlm doctor --verbose

```

> **⚠️ Important:** This tool uses internal Google APIs. Cookies expire every ~2-4 weeks — run `nlm login` again when operations fail. Free tier has ~50 queries/day rate limit.

## Instructions

### Step 1: Verify Tool Availability

Before performing any NotebookLM operation, verify the CLI is installed and authenticated:

```bash

nlm --version && nlm login --check

```

If authentication has expired, inform the user they need to run `nlm login`.

### Step 2: Identify the Target Notebook

List available notebooks or resolve an alias:

```bash

# List all notebooks

nlm notebook list

# Use an alias if configured

nlm alias get <alias-name>

# Get notebook details

nlm notebook get <notebook-id>

```

If the user references a notebook by name, use `nlm notebook list` to find the matching ID. If an alias exists, prefer using the alias.

### Step 3: Perform the Requested Operation

#### Querying a Notebook

Use this to retrieve information from notebook sources:

```bash

# Ask a question against notebook sources

nlm notebook query <notebook-id-or-alias> "What are the login requirements?"

# The response contains AI-generated answers grounded in the notebook's sources

```

**Best practices for queries:**

- Be specific and detailed in your questions

- Reference particular topics or sections when possible

- Use follow-up queries to drill deeper into specific areas

#### Managing Sources

```bash

# List current sources

nlm source list <notebook-id>

# Add a URL source (wait for processing)

nlm source add <notebook-id> --url "https://example.com/docs" --wait

# Add text content

nlm source add <notebook-id> --text "Content here" --title "My Notes"

# Upload a file

nlm source add <notebook-id> --file document.pdf --wait

# Add YouTube video

nlm source add <notebook-id> --youtube "https://youtube.com/watch?v=..."

# Add Google Drive document

nlm source add <notebook-id> --drive <document-id>

# Check for stale Drive sources

nlm source stale <notebook-id>

# Sync stale sources

nlm source sync <notebook-id> --confirm

# Get source content

nlm source get <source-id>

```

#### Creating a Notebook

```bash

# Create a new notebook

nlm notebook create "Project Documentation"

# Set an alias for easy reference

nlm alias set myproject <notebook-id>

```

#### Generating Studio Content

```bash

# Generate audio podcast

nlm audio create <notebook-id> --format deep_dive --length long --confirm

# Formats: deep_dive, brief, critique, debate

# Lengths: short, default, long

# Generate video

nlm video create <notebook-id> --format explainer --style classic --confirm

# Generate report

nlm report create <notebook-id> --format "Briefing Doc" --confirm

# Formats: "Briefing Doc", "Study Guide", "Blog Post"

# Generate quiz

nlm quiz create <notebook-id> --count 10 --difficulty medium --confirm

# Check generation status

nlm studio status <notebook-id>

```

#### Downloading Artifacts

```bash

# Download audio

nlm download audio <notebook-id> <artifact-id> --output podcast.mp3

# Download report

nlm download report <notebook-id> <artifact-id> --output report.md

# Download slides

nlm download slide-deck <notebook-id> <artifact-id> --output slides.pdf

```

#### Research

```bash

# Start web research

nlm research start "query" --notebook-id <notebook-id> --mode fast

# Start deep research

nlm research start "query" --notebook-id <notebook-id> --mode deep

# Poll for completion

nlm research status <notebook-id> --max-wait 300

# Import research results as sources

nlm research import <notebook-id> <task-id>

```

### Step 4: Present Results

- Parse the CLI output and present information clearly to the user

- For queries, present the AI-generated answer with relevant context

- For list operations, format results in a readable table

- For long-running operations (audio, video), inform the user about expected wait times (1-5 minutes)

## Aliases

The alias system provides user-friendly shortcuts for notebook UUIDs:

```bash

nlm alias set <name> <notebook-id> # Create alias

nlm alias list # List all aliases

nlm alias get <name> # Resolve alias to UUID

nlm alias delete <name> # Remove alias

```

Aliases can be used in place of notebook IDs in any command.

## Examples

### Example 1: Query Documentation for Implementation

**Task:** "Write the login use case based on documentation in NotebookLM"

```bash

# 1. Find the project notebook

nlm notebook list

# 2. Query for login requirements

nlm notebook query myproject "What are the login requirements and user authentication flows?"

# 3. Query for specific details

nlm notebook query myproject "What validation rules apply to the login form?"

# 4. Use the retrieved information to implement the feature

```

### Example 2: Build a Research Notebook

**Task:** "Create a notebook with our API docs and generate a summary"

```bash

# 1. Create notebook

nlm notebook create "API Documentation"

# 2. Add sources

nlm source add api-docs --url "https://api.example.com/docs" --wait

nlm source add api-docs --file openapi-spec.yaml --wait

# 3. Generate a briefing doc

nlm report create api-docs --format "Briefing Doc" --confirm

# 4. Wait and download

nlm studio status api-docs

```

### Example 3: Generate a Podcast from Project Docs

```bash

# 1. Add sources to existing notebook

nlm source add myproject --url "https://blog.example.com/release-notes" --wait

# 2. Generate deep-dive podcast

nlm audio create myproject --format deep_dive --length long --confirm

# 3. Poll until ready

nlm studio status myproject

# 4. Download

nlm download audio myproject <artifact-id> --output podcast.mp3

```

## Best Practices

1. **Always verify authentication first** — Run `nlm login --check` before any operation

2. **Use aliases** — Set aliases for frequently-used notebooks to avoid UUID management

3. **Use `--wait` when adding sources** — Ensures sources are processed before querying

4. **Use `--confirm` for destructive/create operations** — Required for non-interactive use

5. **Handle rate limits** — Free tier has ~50 queries/day; space out bulk operations

6. **Cookie expiration** — Sessions last ~2-4 weeks; re-authenticate with `nlm login` when needed

7. **Check source freshness** — Use `nlm source stale` to detect outdated Google Drive sources

8. **Use `--json` for parsing** — When processing output programmatically, use `--json` flag

## Constraints and Warnings

- **Internal APIs**: NotebookLM CLI uses undocumented Google APIs that may change without notice

- **Authentication**: Requires Chrome-based cookie extraction — not suitable for headless CI/CD environments

- **Rate limits**: Free tier is limited to ~50 queries/day

- **Session expiry**: Cookies expire every ~2-4 weeks; requires periodic re-authentication

- **No official support**: This is a community tool, not officially supported by Google

- **Stability**: API changes may break functionality without warning — check for tool updates regularly