### Clone Repository and Install Dependencies

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Clone the project repository, navigate into the directory, and install the project in editable mode. This is the initial setup for development.

```bash
git clone https://github.com/claude-world/notebooklm-skill.git
cd notebooklm-skill
pip install -e .
```

--------------------------------

### MCP Server Setup and Usage

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Instructions for starting and configuring the MCP server for NotebookLM, enabling access for various clients.

```APIDOC
## MCP Server

FastMCP server exposing 13 NotebookLM tools to Claude Code, Cursor, Gemini CLI, and any MCP-compatible client.

### Starting the MCP Server

**stdio mode (for `.mcp.json` integration):**
```bash
# zero install
uvx --from notebooklm-skill notebooklm-mcp

# after pip install
notebooklm-mcp
```

**HTTP mode (remote / multi-client access):**
```bash
notebooklm-mcp --http --port 8765
```

### MCP Configuration (`.mcp.json`)

**For stdio mode:**
```json
{
  "mcpServers": {
    "notebooklm": {
      "command": "uvx",
      "args": ["--from", "notebooklm-skill", "notebooklm-mcp"]
    }
  }
}
```

**For HTTP mode:**
```json
{
  "mcpServers": {
    "notebooklm": {
      "url": "http://localhost:8765/mcp"
    }
  }
}
```

### Available MCP Tools (13)

| Tool                                                | Description                                     |
|-----------------------------------------------------|-------------------------------------------------|
| `nlm_create_notebook(title, sources[], text_sources?)` | Create notebook and add URL/text sources          |
| `nlm_list()`                                        | List all notebooks                              |
| `nlm_delete(notebook)`                              | Delete a notebook by name or ID                 |
| `nlm_add_source(notebook, url?, text?, file_path?)` | Add source to existing notebook                 |
| `nlm_ask(notebook, query)`                          | Ask question, get cited answer                  |
| `nlm_summarize(notebook)`                           | Get notebook summary                            |
| `nlm_list_sources(notebook)`                        | List all sources in notebook                    |
| `nlm_generate(notebook, type, lang?, instructions?)`| Generate artifact (audio/video/slides/report/quiz/flashcards/mind-map/data-table/study-guide) |
| `nlm_download(notebook, type, output_path)`         | Download artifact to local file                 |
| `nlm_list_artifacts(notebook, type?)`               | List artifacts in notebook                      |
| `nlm_research(notebook, query, mode?)`              | Run web research (fast or deep)                 |
| `nlm_research_pipeline(sources[], questions[], output_format?)` | Full research-to-content pipeline               |
| `nlm_trend_research(geo?, count?, platform?)`       | Trending topics → researched content            |
```

--------------------------------

### Start MCP Server for NotebookLM Tools (Bash)

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Launch the MCP server for NotebookLM tools. Use 'uvx' for zero installation or directly after pip installation. Supports stdio and HTTP modes for integration with various clients.

```bash
# Start MCP server (stdio mode, for .mcp.json integration)
uvx --from notebooklm-skill notebooklm-mcp         # zero install
notebooklm-mcp                                       # after pip install

# HTTP mode (remote / multi-client access)
notebooklm-mcp --http --port 8765
```

--------------------------------

### Copy Example Environment File

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Create a local .env file by copying the example configuration file. This allows setting default parameters for notebooklm-skill.

```bash
cp .env.example .env
```

--------------------------------

### One-line Install Script

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Execute the provided install script for a comprehensive setup, including pip, Playwright, and Claude Code Skill.

```bash
git clone https://github.com/claude-world/notebooklm-skill.git
cd notebooklm-skill
./install.sh
```

--------------------------------

### Verify Setup with Core CLI Commands

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Perform a full setup verification by listing notebooks, creating a test notebook from a URL, asking a question, and then deleting the test notebook.

```bash
# List existing NotebookLM notebooks (may be empty)
notebooklm-skill list

# Create a test notebook
notebooklm-skill create \
  --title "Test Notebook" \
  --sources "https://en.wikipedia.org/wiki/Large_language_model"

# Ask a question
notebooklm-skill ask \
  --notebook "Test Notebook" \
  --query "What is a large language model?"

# Clean up
notebooklm-skill delete --notebook "Test Notebook"
```

--------------------------------

### Get Source Guide

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Retrieve a source guide, including an AI summary and keywords for a specific source within a notebook. Requires notebook and source IDs.

```bash
python3 scripts/notebooklm_client.py source-guide --notebook NOTEBOOK_ID --source SOURCE_ID
```

--------------------------------

### NotebookLM Skill Installation Options

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Provides three methods for installing NotebookLM Skill: using uvx for zero installation, pip from PyPI for standard installation, and a one-line script for a comprehensive setup including Playwright and Claude Code Skill symlink.

```bash
# Option A: uvx (zero install, recommended)
uvx notebooklm-skill --help
uvx --from notebooklm-skill notebooklm-mcp   # MCP server

# Option B: pip from PyPI
pip install notebooklm-skill
notebooklm-skill --help
notebooklm-pipeline --help
notebooklm-mcp

# Option C: One-line install (pip + Playwright + Claude Code Skill symlink)
git clone https://github.com/claude-world/notebooklm-skill.git
cd notebooklm-skill && ./install.sh

# Authenticate (one-time)
uvx notebooklm login

# Verify
notebooklm-skill list   # should show your notebooks
```

--------------------------------

### Start Method Response Format

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

The `start()` method returns a dictionary containing task and report identifiers, notebook ID, query, and mode.

```python
{
    "task_id": "abc123",
    "report_id": "def456",
    "notebook_id": "NOTEBOOK_ID",
    "query": "search query",
    "mode": "fast"
}
```

--------------------------------

### Install notebooklm-skill from Source

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Clone the repository and install the notebooklm-skill package from its source code. This method is useful for development or when needing the latest changes.

```bash
git clone https://github.com/claude-world/notebooklm-skill.git
cd notebooklm-skill
pip install .
```

```bash
git clone https://github.com/claude-world/notebooklm-skill.git
cd notebooklm-skill
pip install -r requirements.txt
```

--------------------------------

### Direct script execution example

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Demonstrates how to run the notebooklm_client.py script directly for creating notebooks.

```bash
python scripts/notebooklm_client.py create ...
```

--------------------------------

### Verify Installation with CLI Commands

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Check if the notebooklm-skill installation was successful by listing available notebooks or running client scripts.

```bash
notebooklm-skill list
```

```bash
python scripts/notebooklm_client.py list
```

--------------------------------

### Install notebooklm-skill from PyPI

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Install the notebooklm-skill package directly from the Python Package Index (PyPI) using pip.

```bash
pip install notebooklm-skill
```

--------------------------------

### Start MCP Server with uvx

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Launch the MCP server for notebooklm-skill using uvx. This allows MCP-compatible clients to use NotebookLM as a tool.

```bash
uvx --from notebooklm-skill notebooklm-mcp
```

--------------------------------

### Claude Code Skill Setup (Symlink)

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Install the NotebookLM skill using a symlink for automatic updates via git pull.

```bash
# Option A: Symlink (auto-updates with git pull)
./install.sh
```

--------------------------------

### Start MCP Server

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Launch the MCP server for notebooklm-skill. It runs on stdio by default, enabling communication with MCP-compatible clients.

```bash
notebooklm-mcp
```

```bash
python3 mcp_server/server.py
```

--------------------------------

### Create a new notebook with notebooklm-skill

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Create a new NotebookLM notebook with a specified title and sources. Works with both uvx and pip installations.

```bash
notebooklm-skill create --title "My Research" --sources https://example.com/article
```

--------------------------------

### Describe Notebook

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Get a summary and suggested topics for a specific notebook. Requires the notebook ID.

```bash
python3 scripts/notebooklm_client.py describe --notebook NOTEBOOK_ID
```

--------------------------------

### Start MCP server in stdio mode

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Launch the MCP server for standard input/output operations.

```bash
notebooklm-mcp
```

--------------------------------

### Start Deep Web Research via Built-in CLI

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Initiates a web research task for a given notebook and query using the built-in CLI. This command starts the research process.

```bash
notebooklm research start NOTEBOOK_ID "latest advances in AI agents"
```

--------------------------------

### Install Playwright Browsers

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Fix 'Browser not opening' errors by installing the necessary Playwright browsers. This command ensures that Playwright can launch a browser instance.

```bash
python3 -m playwright install chromium
```

--------------------------------

### Claude Code Skill Setup (Manual Copy)

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Manually copy the NotebookLM skill files to the .claude/skills directory.

```bash
# Option B: Manual copy
mkdir -p .claude/skills/notebooklm
cp /path/to/notebooklm-skill/SKILL.md .claude/skills/notebooklm/
cp /path/to/notebooklm-skill/scripts/*.py .claude/skills/notebooklm/scripts/
cp /path/to/notebooklm-skill/requirements.txt .claude/skills/notebooklm/
```

--------------------------------

### Run Google Login with pip install

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Initiate the Google authentication process for a pip-installed version. This opens a browser for login and saves the session state.

```bash
python3 -m notebooklm login
```

--------------------------------

### Start MCP Server in HTTP Mode

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Start the notebooklm-mcp server in HTTP mode to enable remote or multi-client access. Specify the port for the server to listen on.

```bash
notebooklm-mcp --http --port 8765
```

--------------------------------

### feeds.json Example

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Configuration file for specifying RSS feeds and processing parameters.

```json
{
  "feeds": [
    {"name": "Hacker News", "url": "https://news.ycombinator.com/rss"},
    {"name": "Anthropic Blog", "url": "https://blog.anthropic.com/rss.xml"},
    {"name": "Simon Willison", "url": "https://simonwillison.net/atom/everything/"},
    {"name": "The Register AI", "url": "https://www.theregister.com/software/ai/headlines.atom"}
  ],
  "max_sources_per_feed": 5,
  "date_range_days": 7
}
```

--------------------------------

### Start MCP Server (stdio mode)

Source: https://github.com/claude-world/notebooklm-skill/blob/main/AGENTS.md

Launch the MCP server in standard input/output mode, suitable for integration with tools like Claude Code and Cursor.

```bash
notebooklm-mcp            # stdio mode (Claude Code, Cursor)
```

--------------------------------

### Built-in CLI - Ask Questions

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Examples of using the built-in CLI to ask questions to a notebook, including follow-up questions within a conversation.

```APIDOC
## Built-in CLI - Ask Questions

### Description
Use the built-in CLI to ask questions to a notebook, including follow-up questions within a conversation.

### Commands
```bash
notebooklm chat NOTEBOOK_ID "What are the key differences between ReAct and Reflexion?"
notebooklm chat NOTEBOOK_ID "Can you elaborate on point 3?" --conversation CONV_ID
```
```

--------------------------------

### Start MCP Server (HTTP mode)

Source: https://github.com/claude-world/notebooklm-skill/blob/main/AGENTS.md

Launch the MCP server in HTTP mode, making it accessible on a specified port (defaulting to 8765).

```bash
notebooklm-mcp --http     # HTTP mode on port 8765
```

--------------------------------

### Research-to-Article Pipeline

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Execute the full research-to-article pipeline, which includes creating a notebook from sources, asking questions, and writing an article. Can start from URLs or an existing notebook.

```bash
# Full pipeline: create notebook -> ask questions -> write article
python3 scripts/pipeline.py research-to-article \
  --sources "https://url1.com" "https://url2.com" \
  --title "AI Agent Frameworks in 2026" \
  --output article.md
```

```bash
# From existing notebook
python3 scripts/pipeline.py research-to-article \
  --notebook NOTEBOOK_ID \
  --topic "AI Agent Frameworks" \
  --output article.md
```

--------------------------------

### Ingest Sources via CLI

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Add various types of sources to a notebook using the built-in CLI. Supported formats include URLs (web and YouTube), text content, and files (PDF, DOCX, Markdown, CSV). You can also list sources, get AI summaries, or retrieve full indexed text.

```bash
# --- Built-in CLI ---
notebooklm source add NOTEBOOK_ID --url "https://arxiv.org/abs/2401.12345"
notebooklm source add NOTEBOOK_ID --url "https://youtube.com/watch?v=VIDEO_ID"
notebooklm source add NOTEBOOK_ID --text "Notes Title" --content "Full text here..."
notebooklm source add NOTEBOOK_ID --file /path/to/doc.pdf
notebooklm source list NOTEBOOK_ID
notebooklm source guide NOTEBOOK_ID SOURCE_ID      # AI summary + keywords
notebooklm source fulltext NOTEBOOK_ID SOURCE_ID   # Full indexed text
```

--------------------------------

### Research API: Start Method

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Initiates a research session within a notebook. Requires a notebook ID and a query. Optionally accepts a source ('web' or 'drive') and a mode ('fast' or 'deep'). Returns a dictionary or None.

```python
start(notebook_id, query, source?, mode?)
```

--------------------------------

### Create a Notebook with Sources

Source: https://github.com/claude-world/notebooklm-skill/blob/main/AGENTS.md

Create a new NotebookLM notebook with a specified title and provide initial sources, such as URLs.

```bash
notebooklm-skill create --title "Research" --sources https://example.com
```

--------------------------------

### Client Initialization (Python API)

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Demonstrates how to initialize the `NotebookLMClient` as an async context manager, loading a stored browser session to access NotebookLM's sub-APIs.

```APIDOC
## Client Initialization (Python API)

`NotebookLMClient` is an async context manager that loads the stored browser session and provides all 8 sub-APIs.

```python
import asyncio
from notebooklm import NotebookLMClient
from notebooklm.auth import AuthTokens

async def main():
    # From default storage (~/.notebooklm/storage_state.json)
    async with await NotebookLMClient.from_storage() as client:
        notebooks = await client.notebooks.list()
        print(f"Found {len(notebooks)} notebooks")

    # From a custom path
    async with await NotebookLMClient.from_storage(path="/custom/storage.json") as client:
        nb = await client.notebooks.create("My Research")
        print(nb.id)  # UUID string

asyncio.run(main())
```
```

--------------------------------

### Create Notebook and Research Topic

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Use this sequence to create a new notebook with specified sources, then ask research questions and generate a report. Ensure sources are processed with `--wait` before asking questions.

```bash
# Step 1: Create notebook with source URLs
python3 scripts/notebooklm_client.py create \
  --title "AI Agent Frameworks 2026" \
  --sources \
    "https://arxiv.org/abs/2401.12345" \
    "https://blog.openai.com/agents" \
    "https://docs.anthropic.com/agent-sdk" \
    "https://www.youtube.com/watch?v=abc123" \
  --wait

# Step 2: Get notebook description (AI overview + suggested questions)
python3 scripts/notebooklm_client.py describe \
  --notebook NOTEBOOK_ID

# Step 3: Ask research questions
python3 scripts/notebooklm_client.py ask \
  --notebook NOTEBOOK_ID \
  --question "What are the main AI agent frameworks available in 2026?"

python3 scripts/notebooklm_client.py ask \
  --notebook NOTEBOOK_ID \
  --question "How do these frameworks compare in terms of capabilities?"

python3 scripts/notebooklm_client.py ask \
  --notebook NOTEBOOK_ID \
  --question "What are the emerging trends and future directions?"

# Step 4: Generate a briefing doc for structured overview
python3 scripts/notebooklm_client.py generate report \
  --notebook NOTEBOOK_ID \
  --format briefing_doc

# Step 5: Full pipeline (combines steps 1-4)
python3 scripts/pipeline.py research-to-article \
  --sources "https://url1" "https://url2" "https://url3" \
  --topic "AI Agent Frameworks in 2026" \
  --questions \
    "What are the main frameworks?" \
    "How do they compare?" \
    "What trends are emerging?" \
  --output article.md
```

--------------------------------

### Python API - Notebook and Source Management

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Demonstrates how to initialize the NotebookLM client, create a new notebook, and add various types of sources (URL, text, file) to it.

```APIDOC
## Python API - Notebook and Source Management

### Description
Initialize the NotebookLM client, create a new notebook, and add various types of sources (URL, text, file) to it.

### Method
```python
from notebooklm import NotebookLMClient

async with await NotebookLMClient.from_storage() as client:
    # Create notebook
    nb = await client.notebooks.create("AI Research")

    # Add sources
    src1 = await client.sources.add_url(nb.id, "https://example.com", wait=True)
    src2 = await client.sources.add_text(nb.id, "Notes", "Content...", wait=True)
    src3 = await client.sources.add_file(nb.id, "/path/to/doc.pdf", wait=True)
```
```

--------------------------------

### One-line install with Playwright and Claude Code Skill

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

A convenient script for a complete one-line installation, including Playwright and Claude Code Skill.

```bash
git clone https://github.com/claude-world/notebooklm-skill.git
cd notebooklm-skill && ./install.sh
```

--------------------------------

### Generate Slides, Podcast, and Video

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

This multi-step process first generates slides and a podcast using NotebookLM client, then converts slides to images and composes a video with the podcast.

```bash
# Generate slides and podcast
python scripts/notebooklm_client.py generate --notebook "Research" --type slides
python scripts/notebooklm_client.py podcast --notebook "Research" --lang en --output podcast.m4a
python scripts/notebooklm_client.py download --notebook "Research" --type slides --output slides.pdf

# Convert PDF to PNG + compose video
./scripts/make_video.sh slides.pdf podcast.m4a output.mp4
```

--------------------------------

### Report Content Example

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/output_formats.md

Example of the markdown content retrieved for a generated report. This includes sections like Executive Summary, Key Themes, and Important Quotes.

```markdown
# Briefing Doc: AI Agent Frameworks

## Executive Summary
This briefing document analyzes the current landscape of AI agent frameworks...

## Key Themes

### 1. Tool-Use Paradigm
Sources describe a shift toward agents that can use external tools...

### 2. Multi-Agent Coordination
Several papers discuss how multiple agents can collaborate...

## Important Quotes
> "ReAct prompting synergizes reasoning and acting..." - Source 1
> "The future of AI agents lies in their ability to..." - Source 3

## Actionable Insights
1. Consider implementing tool-use capabilities...
2. Multi-agent architectures show promise for...

```

--------------------------------

### Source Guide Response Structure

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Represents the response structure for a source guide request, containing an AI-generated summary and a list of keywords related to the source content.

```json
{
    "summary": "AI-generated summary with **bold** keywords (markdown)",
    "keywords": ["topic1", "topic2", "topic3"]
}
```

--------------------------------

### Wrapper CLI - Generate Video Overview

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Generate a video overview of the notebook content using the wrapper CLI.

```APIDOC
## Wrapper CLI - Generate Video Overview

### Description
Generate a video overview of the notebook content using the wrapper CLI.

### Command
```bash
# 2. Video Overview
python3 scripts/notebooklm_client.py generate video \
  --notebook NOTEBOOK_ID \
  --format explainer \
  --style whiteboard
```
```

--------------------------------

### CLI Command: create

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Creates a new notebook using specified URL or text sources.

```APIDOC
## create

### Description
Create a notebook with URL/text sources.

### Method
CLI Command

### Endpoint
`notebooklm create`

### Parameters
#### Query Parameters
- **sources** (string array) - Required - URLs or text content for the notebook.

### Request Example
```bash
notebooklm create --sources "https://example.com/article" "Some text content"
```
```

--------------------------------

### Generate Study Guide Report

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Generate a study guide report from a notebook. This format is useful for creating structured notes and summaries of the notebook's content.

```bash
python3 scripts/notebooklm_client.py generate report \
  --notebook NOTEBOOK_ID \
  --format study_guide
```

--------------------------------

### Wrapper CLI - Generate Audio Overview

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Generate an audio overview of the notebook content using the wrapper CLI.

```APIDOC
## Wrapper CLI - Generate Audio Overview

### Description
Generate an audio overview of the notebook content using the wrapper CLI.

### Command
```bash
# 1. Audio Overview (podcast-style discussion)
python3 scripts/notebooklm_client.py generate audio \
  --notebook NOTEBOOK_ID \
  --language en \
  --format deep_dive \
  --length default \
  --instructions "Focus on practical implications"
```
```

--------------------------------

### Create Notebook for Source Comparison

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Create a NotebookLM notebook with multiple documentation URLs for comparative analysis.

```python
python3 scripts/notebooklm_client.py create \
  --title "LLM Framework Comparison" \
  --sources \
    "https://docs.langchain.com/docs/get_started/introduction" \
    "https://docs.llamaindex.ai/en/stable/" \
    "https://docs.anthropic.com/agent-sdk/overview" \
    "https://python.langchain.com/docs/concepts/" \
  --wait
```

--------------------------------

### Register MCP Server with Claude Code (pip install)

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Configure Claude Code to use the notebooklm-skill MCP server by adding an entry to the .mcp.json file, assuming a pip installation.

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

--------------------------------

### NotebookLMClient Initialization

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Demonstrates how to initialize the NotebookLMClient using different authentication methods, including from storage and directly with auth tokens. The client is designed to be used as an async context manager.

```APIDOC
## Client Initialization

```python
from notebooklm import NotebookLMClient

# From stored browser session (recommended)
async with await NotebookLMClient.from_storage() as client:
    notebooks = await client.notebooks.list()

# From stored session at custom path
async with await NotebookLMClient.from_storage(path="/custom/storage_state.json") as client:
    ...

# From AuthTokens directly
from notebooklm.auth import AuthTokens
auth = AuthTokens(cookies, csrf_token, session_id)
async with NotebookLMClient(auth, timeout=30.0) as client:
    ...
```

### Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `path` | `str | None` | `None` | Path to `storage_state.json`. Default: `~/.notebooklm/storage_state.json` |
| `timeout` | `float` | `30.0` | HTTP request timeout in seconds |

### Properties

| Property | Type | Description |
|---|---|---|
| `auth` | `AuthTokens` | Current authentication tokens |
| `is_connected` | `bool` | Whether the HTTP client is open |

### Methods

| Method | Returns | Description |
|---|---|---|
| `refresh_auth()` | `AuthTokens` | Refresh CSRF token and session ID |
```

--------------------------------

### Source Guide Response

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/output_formats.md

The JSON response providing a summary and keywords for a given source.

```APIDOC
## Source Guide Response

### Description
This JSON object provides a summarized overview and extracted keywords for a specific source.

### Response
#### Success Response (200)
- **summary** (string) - A concise summary of the source content.
- **keywords** (array of strings) - A list of relevant keywords extracted from the source.

### Response Example
```json
{
  "summary": "This article discusses the **evolution of AI agents** from simple rule-based systems to sophisticated **autonomous frameworks**. Key topics include **ReAct prompting**, **tool use**, and **multi-agent coordination**. The author argues that...",
  "keywords": [
    "AI agents",
    "ReAct",
    "tool use",
    "multi-agent systems",
    "autonomous frameworks"
  ]
}
```
```

--------------------------------

### CLI Command: list

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Lists all available notebooks.

```APIDOC
## list

### Description
List all notebooks.

### Method
CLI Command

### Endpoint
`notebooklm list`

### Request Example
```bash
notebooklm list
```
```

--------------------------------

### Wrapper CLI - Ask Questions

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Demonstrates how to use the wrapper CLI to ask questions, specifying sources, and continuing conversations.

```APIDOC
## Wrapper CLI - Ask Questions

### Description
Use the wrapper CLI to ask questions, specifying sources, and continuing conversations.

### Commands
```bash
# Ask a question -- answer includes source citations
python3 scripts/notebooklm_client.py ask \
  --notebook NOTEBOOK_ID \
  --query "What are the key differences between ReAct and Reflexion agents?"

# Ask with specific sources only
python3 scripts/notebooklm_client.py ask \
  --notebook NOTEBOOK_ID \
  --query "Summarize the main findings" \
  --sources SOURCE_ID_1 SOURCE_ID_2

# Follow-up question (maintains conversation context)
python3 scripts/notebooklm_client.py ask \
  --notebook NOTEBOOK_ID \
  --query "Can you elaborate on point 3?" \
  --conversation CONVERSATION_ID
```
```

--------------------------------

### Slides + Podcast to YouTube Video (Bash)

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

This process combines NotebookLM-generated slides (PDF) and podcast audio (M4A) into a YouTube-ready MP4 video using ffmpeg and ImageMagick. It involves generating and downloading artifacts first, then composing the video.

```bash
# Step 1: Generate and download artifacts
notebooklm-skill generate slide-deck --notebook NOTEBOOK_ID
notebooklm-skill generate audio --notebook NOTEBOOK_ID --format deep_dive --length long
notebooklm-skill download slide-deck --notebook NOTEBOOK_ID --output slides.pdf
notebooklm-skill download audio --notebook NOTEBOOK_ID --output podcast.m4a

# Step 2: Compose video (requires ffmpeg + ImageMagick)
./scripts/make_video.sh slides.pdf podcast.m4a output.mp4
# Output: YouTube-ready MP4 with slide images timed to podcast audio
```

--------------------------------

### Initialize NotebookLMClient

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Initialize the client using stored browser session data or directly with authentication tokens. The client is an async context manager.

```python
from notebooklm import NotebookLMClient

# From stored browser session (recommended)
async with await NotebookLMClient.from_storage() as client:
    notebooks = await client.notebooks.list()

# From stored session at custom path
async with await NotebookLMClient.from_storage(path="/custom/storage_state.json") as client:
    ...
```

```python
# From AuthTokens directly
from notebooklm.auth import AuthTokens
auth = AuthTokens(cookies, csrf_token, session_id)
async with NotebookLMClient(auth, timeout=30.0) as client:
    ...
```

--------------------------------

### Ask a Question to a Notebook

Source: https://github.com/claude-world/notebooklm-skill/blob/main/AGENTS.md

Query a specific NotebookLM notebook to get answers and insights based on its content.

```bash
notebooklm-skill ask --notebook "Research" --query "Key findings?"
```

--------------------------------

### Run Google Login with uvx

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Initiate the Google authentication process using uvx. This opens a browser for login and saves the session state.

```bash
uvx notebooklm login
```

--------------------------------

### Configure Trend-Pulse URL

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Add the TREND_PULSE_URL to your .env file to enable trend-pulse integration. Ensure trend-pulse is installed and running.

```bash
TREND_PULSE_URL=http://localhost:3002
```

--------------------------------

### Wrapper CLI - Generate Report

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Generate a report (e.g., briefing doc, study guide, blog post) from the notebook content.

```APIDOC
## Wrapper CLI - Generate Report

### Description
Generate a report (e.g., briefing doc, study guide, blog post) from the notebook content.

### Commands
```bash
# 5. Report (Briefing Doc / Study Guide / Blog Post / Custom)
python3 scripts/notebooklm_client.py generate report \
  --notebook NOTEBOOK_ID \
  --format briefing_doc

# 6. Study Guide (convenience shortcut for report format=study_guide)
python3 scripts/notebooklm_client.py generate report \
  --notebook NOTEBOOK_ID \
  --format study_guide
```
```

--------------------------------

### Create Notebook with Sources via Python Client

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Use the Python client to create a new notebook, specifying a title and multiple source URLs.

```bash
python3 scripts/notebooklm_client.py create \
  --title "AI Agents Research" \
  --sources \
    "https://arxiv.org/abs/2401.12345" \
    "https://blog.example.com/ai-agents-2026"
```

--------------------------------

### ChatGoal Enum

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Defines the possible goals for chat interactions, such as default behavior, custom goals, or specifically aiming to be a learning guide.

```python
class ChatGoal(Enum):
    DEFAULT = 1
    CUSTOM = 2
    LEARNING_GUIDE = 3
```

--------------------------------

### ChatMode Enum

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Enumerates the different predefined modes for chat interactions, including default, learning guide, concise, and detailed responses.

```python
class ChatMode(Enum):
    DEFAULT = "default"
    LEARNING_GUIDE = "learning_guide"
    CONCISE = "concise"
    DETAILED = "detailed"
```

--------------------------------

### List Notebooks

Source: https://github.com/claude-world/notebooklm-skill/blob/main/AGENTS.md

List all existing NotebookLM notebooks.

```bash
notebooklm-skill list
```

--------------------------------

### Add Various Sources to Notebook

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Demonstrates adding different types of sources to a notebook using the notebooklm CLI. Supports URLs, text content, and local files.

```bash
notebooklm source add NOTEBOOK_ID --url "https://arxiv.org/abs/2401.12345"
notebooklm source add NOTEBOOK_ID --url "https://youtube.com/watch?v=VIDEO_ID"
notebooklm source add NOTEBOOK_ID --text "Custom Notes" --content "Full text here..."
notebooklm source add NOTEBOOK_ID --file /path/to/document.pdf
```

--------------------------------

### generate_study_guide

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Conveniently generates a study guide from the notebook content. Accepts notebook ID, source IDs, language, and extra instructions.

```APIDOC
## generate_study_guide

### Description
Generate study guide (convenience).

### Method Signature
`generate_study_guide(notebook_id, source_ids?, language="en", extra_instructions?)

### Parameters
- **notebook_id**: The ID of the notebook to generate the study guide from.
- **source_ids** (optional): A list of source IDs to include in the study guide.
- **language** (optional, default: "en"): The language for the study guide.
- **extra_instructions** (optional): Additional instructions for study guide generation.

### Returns
`GenerationStatus`
```

--------------------------------

### Create Notebook with Deep-Dive Sources

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Create a new notebook and populate it with multiple sources for a deep dive. Supports various source types including URLs and GitHub links. The `--wait` flag ensures the notebook is ready before proceeding.

```bash
python3 scripts/notebooklm_client.py create \
  --title "Deep Dive: The Future of AI Coding Assistants" \
  --sources \
    "https://arxiv.org/abs/2401.99999" \
    "https://github.blog/ai-coding-assistant-report-2026" \
    "https://youtube.com/watch?v=keynote123" \
    "https://stackoverflow.blog/2026/ai-coding-survey" \
    "https://docs.anthropic.com/claude-code" \
  --wait
```

--------------------------------

### Generate a podcast from a notebook

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Create an audio podcast from the content of a NotebookLM notebook. Specify the language and output file.

```bash
notebooklm-skill podcast --notebook "My Research" --lang en --output podcast.m4a
```

--------------------------------

### List notebooks to confirm authentication

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Verify that the authentication was successful by listing available notebooks.

```bash
uvx notebooklm-skill list
```

--------------------------------

### Expected Output for Trend-to-Content Pipeline

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Example of the structured JSON output generated by the trend-to-content pipeline, including trend details and social posts.

```json
{
  "trend": {"topic": "Claude Code 2.0", "source": "hackernews", "heat_score": 450},
  "posts": {
    "threads": "Claude Code 2.0 剛發布，3 個你必須知道的改變：\n\n1. ...\n\n你最期待哪個功能？",
    "instagram": "Claude Code 2.0: Everything You Need to Know\n\n...\n\n#ClaudeCode #AI #DevTools",
    "article": "# Claude Code 2.0: What Developers Need to Know\n\n..."
  }
}
```

--------------------------------

### Get Full Source Text

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Retrieve the full indexed text of a specific source within a notebook. Requires notebook and source IDs.

```bash
python3 scripts/notebooklm_client.py fulltext --notebook NOTEBOOK_ID --source SOURCE_ID
```

--------------------------------

### Perform Web Research (CLI)

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Command-line interface for initiating web research. Supports 'fast' mode for quick URL lists and summaries, and 'deep' mode for comprehensive reports. Polling and auto-import are also available.

```bash
# --- Built-in CLI ---
notebooklm research start NOTEBOOK_ID "latest advances in AI agents"
notebooklm research poll NOTEBOOK_ID

# --- Wrapper CLI ---
# Fast mode (10-30 sec): returns URL list + brief summary
notebooklm-skill research --notebook NOTEBOOK_ID --query "latest AI agent frameworks" \
  --source web --mode fast

# Deep mode (1-5 min): returns full research report + URLs
notebooklm-skill research --notebook NOTEBOOK_ID --query "AI agent frameworks comparison" \
  --source web --mode deep

# Poll results and auto-import top 5 discovered sources
notebooklm-skill research-poll --notebook NOTEBOOK_ID --import-top 5
```

--------------------------------

### Chat API: Get Conversation ID Method

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Retrieves the most recent conversation ID for a given notebook. This is useful for continuing a previous conversation.

```python
get_conversation_id(notebook_id)
```

--------------------------------

### Initialize NotebookLM Client (Python API)

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Initialize the NotebookLMClient as an async context manager to load the stored browser session. This client provides access to all 8 sub-APIs. You can load from the default storage path or a custom path.

```python
import asyncio
from notebooklm import NotebookLMClient
from notebooklm.auth import AuthTokens

async def main():
    # From default storage (~/.notebooklm/storage_state.json)
    async with await NotebookLMClient.from_storage() as client:
        notebooks = await client.notebooks.list()
        print(f"Found {len(notebooks)} notebooks")

    # From a custom path
    async with await NotebookLMClient.from_storage(path="/custom/storage.json") as client:
        nb = await client.notebooks.create("My Research")
        print(nb.id)  # UUID string

asyncio.run(main())
```

--------------------------------

### Full Auto-Pilot Mode: Single Run Workflow

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

This describes the steps for a complete auto-pilot mode where NotebookLM handles the entire flow from collecting sources to outputting content and artifacts.

```text
1. Collect source URLs from user or trend-pulse
2. Create notebook: `notebooklm_client.py create --title "Topic" --sources url1 url2`
3. Optionally run deep web research to discover more sources
4. Wait for source processing
5. Ask research questions: `notebooklm_client.py ask --query "Q1"`
6. Generate requested artifacts (audio, video, report, quiz, slides, etc.)
7. Claude writes content using research answers (with citations)
8. Output article/posts/report + downloadable artifacts
```

--------------------------------

### Research to Article Pipeline Script

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Usage examples for the `pipeline.py` script to automate the process of researching and generating an article from given sources or an existing notebook.

```APIDOC
## Pipeline: Research to Article

Full end-to-end pipeline: create notebook → ask research questions → Claude writes article.

### Example 1: From URLs

```bash
python3 scripts/pipeline.py research-to-article \
  --sources "https://arxiv.org/abs/2401.12345" \
            "https://blog.openai.com/agents" \
            "https://youtube.com/watch?v=abc123" \
  --title "AI Agent Frameworks in 2026" \
  --output article.md
```

### Example 2: From Existing Notebook

```bash
python3 scripts/pipeline.py research-to-article \
  --notebook NOTEBOOK_ID \
  --topic "AI Agent Frameworks" \
  --questions "What are the main frameworks?" \
              "How do they compare?" \
              "What trends are emerging?" \
  --output article.md
```

### Output Example (JSON Progress)

```json
{
  "pipeline": "research-to-article",
  "notebook_id": "notebook-uuid",
  "topic": "AI Agent Frameworks in 2026",
  "sources_count": 5,
  "questions_asked": 3,
  "research": {
    "questions": [
      {"question": "What are the main frameworks?", "answer": "Based on sources...", "citations": 4}
    ]
  },
  "article": {
    "title": "AI Agent Frameworks in 2026: A Comprehensive Guide",
    "content": "# AI Agent Frameworks in 2026\n\n...",
    "word_count": 1500,
    "reading_time_minutes": 6
  }
}
```
```

--------------------------------

### Run Tests

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Execute the project's test suite using pytest. Ensure all tests pass to verify the development setup and code integrity.

```bash
python -m pytest tests/
```

--------------------------------

### Wrapper CLI - Generate Slide Deck

Source: https://github.com/claude-world/notebooklm-skill/blob/main/SKILL.md

Generate a slide deck from the notebook content using the wrapper CLI.

```APIDOC
## Wrapper CLI - Generate Slide Deck

### Description
Generate a slide deck from the notebook content using the wrapper CLI.

### Command
```bash
# 4. Slide Deck
python3 scripts/notebooklm_client.py generate slide-deck \
  --notebook NOTEBOOK_ID \
  --format detailed_deck
```
```

--------------------------------

### CLI Command: add-source

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Adds a source (URL, text, or file) to an existing notebook.

```APIDOC
## add-source

### Description
Add a source (URL, text, or file) to an existing notebook.

### Method
CLI Command

### Endpoint
`notebooklm add-source`

### Parameters
#### Query Parameters
- **notebook** (string) - Required - The name of the notebook.
- **source** (string) - Required - The URL, text, or file path to add.

### Request Example
```bash
notebooklm add-source --notebook "My Research Notes" --source "https://example.com/new-article.pdf"
```
```

--------------------------------

### Run CLI Directly with uvx

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Use uvx to run the notebooklm-skill CLI commands directly without installation. Useful for quick checks or running specific commands.

```bash
uvx notebooklm-skill --help
```

--------------------------------

### CLI Command: qa

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Shortcut for generating a quiz artifact from a notebook.

```APIDOC
## qa

### Description
Shortcut for `generate --type quiz`. Generates a quiz based on the notebook content.

### Method
CLI Command

### Endpoint
`notebooklm qa`

### Parameters
#### Query Parameters
- **notebook** (string) - Required - The name of the notebook.

### Request Example
```bash
notebooklm qa --notebook "History Lesson"
```
```

--------------------------------

### Research to Social Posts Output (JSON)

Source: https://context7.com/claude-world/notebooklm-skill/llms.txt

Example JSON output for the research-to-social pipeline, detailing generated posts for different platforms, character counts, and source citations.

```json
// Output: posts.json
{
  "pipeline": "research-to-social",
  "notebook_id": "notebook-uuid",
  "topic": "AI Agents",
  "posts": {
    "threads": {
      "text": "3 things I learned researching AI agents today:\n\n1. ReAct vs Reflexion isn't about which is better — it's about when each shines.\n\n2. Memory is the real differentiator...\n\n你覺得哪個 framework 最有潛力？",
      "char_count": 245
    },
    "instagram": {
      "caption": "AI Agent Frameworks: What You Need to Know in 2026\n\n#AIAgents #MachineLearning #ReAct",
      "char_count": 890
    }
  },
  "source_citations": ["Based on: arxiv.org/abs/2401.12345"]
}
```

--------------------------------

### Create Notebook with Trend Sources

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/pipeline_recipes.md

Create a new NotebookLM notebook with specified URLs as sources for trend analysis.

```python
python3 scripts/notebooklm_client.py create \
  --title "Trending: Claude Code 2.0" \
  --sources \
    "https://news.ycombinator.com/item?id=12345" \
    "https://docs.anthropic.com/claude-code/changelog" \
    "https://x.com/AnthropicAI/status/..." \
  --wait
```

--------------------------------

### Manually Copy Claude Code Skill Files

Source: https://github.com/claude-world/notebooklm-skill/blob/main/docs/SETUP.md

Install the Claude Code Skill by manually copying the necessary files (SKILL.md, scripts, requirements.txt) to the Claude skills directory.

```bash
# Option B: Manual copy
mkdir -p .claude/skills/notebooklm
cp /path/to/notebooklm-skill/SKILL.md .claude/skills/notebooklm/
cp -r /path/to/notebooklm-skill/scripts/ .claude/skills/notebooklm/scripts/
cp /path/to/notebooklm-skill/requirements.txt .claude/skills/notebooklm/
```

--------------------------------

### Research API (`client.research`)

Source: https://github.com/claude-world/notebooklm-skill/blob/main/references/api_surface.md

Initiate and manage research sessions within the NotebookLM Skill. This includes starting new research tasks, polling for results, and importing discovered sources.

```APIDOC
## start(notebook_id, query, source?, mode?)

### Description
Starts a new research session for a given notebook.

### Method
`start`

### Parameters
- **notebook_id** (str) - Required - The ID of the notebook.
- **query** (str) - Required - The research query.
- **source** (str) - Optional - The source to research from (`"web"` or `"drive"`, defaults to `"web"`).
- **mode** (str) - Optional - The research mode (`"fast"` or `"deep"`, defaults to `"fast"`). Note: `"deep"` mode is only available for web sources.

### Returns
`dict | None` - A dictionary containing information about the started research session, or None if it failed.
```

```APIDOC
## poll(notebook_id)

### Description
Polls for the results of an ongoing research session.

### Method
`poll`

### Parameters
- **notebook_id** (str) - Required - The ID of the notebook.

### Returns
`dict` - A dictionary containing the current status and results of the research session.
```

```APIDOC
## import_sources(notebook_id, task_id, sources)

### Description
Imports discovered sources into a notebook for a specific research task.

### Method
`import_sources`

### Parameters
- **notebook_id** (str) - Required - The ID of the notebook.
- **task_id** (str) - Required - The ID of the research task.
- **sources** (list[dict]) - Required - A list of dictionaries, where each dictionary represents a source to import.

### Returns
`list[dict]` - A list of dictionaries representing the imported sources.
```

--------------------------------

### CLI Command: podcast

Source: https://github.com/claude-world/notebooklm-skill/blob/main/README.md

Shortcut for generating audio artifact (podcast) and auto-downloading it.

```APIDOC
## podcast

### Description
Shortcut for `generate --type audio`. Automatically downloads the generated podcast.

### Method
CLI Command

### Endpoint
`notebooklm podcast`

### Parameters
#### Query Parameters
- **notebook** (string) - Required - The name of the notebook.
- **lang** (string) - Required - The language for the podcast audio.
- **output** (string) - Required - The output filename for the podcast audio.

### Request Example
```bash
notebooklm podcast --notebook "My Research" --lang en --output podcast.m4a
```
```