NotebookLM Fast Research vs Deep Research: Understanding the Two Query Modes

Fast research performs quick web or Drive scans returning URLs immediately, while deep research triggers exhaustive web-only crawls with richer summaries but significantly longer processing times.

The teng-lin/notebooklm-py library exposes two distinct research depths when adding sources via the source add-research command. Understanding the technical differences between fast research and deep research modes helps developers optimize latency versus comprehensiveness in automated workflows.

Core Architectural Differences

RPC Method Signatures and Payloads

The divergence between modes begins in src/notebooklm/_research.py within the ResearchAPI.start method, which constructs distinct RPC payloads for Google’s internal batchexecute endpoint.

Fast research invokes the START_FAST_RESEARCH method (ID: Ljjv0c) with a compact four-element array:

params = [[query, source_type], None, 1, notebook_id]
rpc_id = RPCMethod.START_FAST_RESEARCH

Deep research calls START_DEEP_RESEARCH (ID: QA9ei) using a five-element payload where the integer 5 signals the heavyweight pipeline:

params = [None, [1], [query, source_type], 5, notebook_id]
rpc_id = RPCMethod.START_DEEP_RESEARCH

The method IDs are defined in src/notebooklm/rpc/types.py and documented in docs/rpc-reference.md.

Source Type Validation

Fast research supports both web (source_type=1) and Drive (source_type=2) sources via the --from flag. Deep research validates strictly against web-only queries, raising a ValidationError if you attempt to combine mode=deep with source=drive. This constraint reflects the server-side architecture: deep mode triggers a full-stack web crawler that cannot access Google Drive indices.

Operational Characteristics

Processing Pipeline and Latency

Fast research utilizes a lightweight search pipeline that queries existing indexes and returns results within seconds. This makes it suitable for ad-hoc queries where blocking execution is acceptable.

Deep research activates the heavyweight research pipeline, which crawls additional pages, performs supplementary ranking algorithms, and generates summaries. According to the source code, this operation is classified as a long-running task that may require many minutes to complete.

Response Data Structures

The return formats differ significantly in ResearchAPI.poll (located in src/notebooklm/_research.py):

• Fast research returns sources as [url, title, description, type, …]. The presence of URLs allows the CLI to import sources immediately without secondary resolution.
• Deep research returns [None, title, None, type, …, [report]]. URLs are omitted initially (gathered later during import), and the extra [report] field contains a generated summary of the discovered content.

Practical Implementation

Command-Line Workflows

Use fast research for synchronous, low-latency operations:

# Fast web research (blocking)

notebooklm source add-research "Quantum computing basics" --mode fast

# Fast Drive research (blocking)

notebooklm source add-research "Project plan" --from drive --mode fast

Use deep research for asynchronous, agent-oriented workflows with the --no-wait flag:

# Deep web research (non-blocking)

notebooklm source add-research "AI safety papers" --mode deep --no-wait

# Poll for completion and import results

notebooklm research wait --import-all

Python API Integration

The Python client in src/notebooklm/_research.py exposes these modes through the research.start method:

from notebooklm import NotebookLMClient
import asyncio

async with await NotebookLMClient.from_storage() as client:
    # Fast research: web or drive, returns immediately

    fast_result = await client.research.start(
        notebook_id, 
        "large language models",
        mode="fast"
    )
    
    # Deep research: web only, long-running

    deep_task = await client.research.start(
        notebook_id, 
        "large language models",
        mode="deep", 
        source="web"
    )
    
    # Poll until completion for deep research

    while True:
        status = await client.research.poll(notebook_id)
        if status["status"] == "completed":
            break
        await asyncio.sleep(5)
    
    # Import discovered sources

    await client.research.import_sources(
        notebook_id, 
        deep_task["task_id"], 
        status["sources"]
    )

When to Use Each Mode

Choose fast research when:

• Latency is critical and you need results within seconds
• You are querying both web and Drive sources in the same workflow
• Building scripts that require deterministic, short-lived request cycles

Choose deep research when:

• Conducting comprehensive literature reviews requiring exhaustive web crawling
• Working with agent-oriented systems that can tolerate multi-minute processing times
• You need the enriched [report] summaries generated by the deep pipeline

Summary

• Fast research (START_FAST_RESEARCH) supports web and Drive sources, returns URLs immediately, and completes in seconds using a lightweight pipeline.
• Deep research (START_DEEP_RESEARCH) is web-only, omits URLs initially in favor of summary reports, and triggers long-running exhaustive crawls flagged by the integer 5 in the RPC payload.
• Both modes return a task_id for polling via ResearchAPI.poll, but deep research requires asynchronous handling with notebooklm research wait or manual polling loops.
• The implementation enforces source-type validation in src/notebooklm/_research.py, preventing invalid deep research queries against Drive sources.

Frequently Asked Questions

Can I use deep research mode with Google Drive sources?

No. According to the validation logic in src/notebooklm/_research.py, deep research explicitly supports web sources only. Attempting to execute notebooklm source add-research "query" --from drive --mode deep raises a ValidationError because the heavyweight crawler cannot access Drive indices.

Why does deep research take significantly longer than fast research?

Deep research triggers the full-stack web crawler and summarizer on Google's servers, which performs multi-page crawling, additional ranking algorithms, and generates comprehensive summaries. The RPC payload includes a fixed flag 5 that signals this resource-intensive pipeline, whereas fast research queries existing lightweight indexes.

How do I handle the asynchronous nature of deep research in production scripts?

Use the --no-wait flag with the CLI to return immediately with a task_id, then poll using notebooklm research wait or the Python ResearchAPI.poll method. In Python, implement a polling loop that checks status["status"] until it returns "completed" before calling ResearchAPI.import_sources to finalize the discovered content.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}