notebooklm-mcp-cli

Install specialized skill/reference documentation for AI tools that do not use MCP using nlm skill install.

Supported Tools: claude-code, cursor, agents, gemini-cli, codex, opencode, antigravity, cline, openclaw, alef-agent, other.

Installation Targets:

• Generic/Codex/Gemini-CLI: Installs to ~/.agents/skills/nlm-skill/.
• Alef Agent: Installs to ~/.alef-agent/workspace/skills/nlm-skill/.

Commands:

• nlm skill install claude-code
• nlm skill install agents (Alias for claude-code, codex, or gemini-cli targets).
• nlm skill install alef-agent

nlm skill list                           # Show installation status
nlm skill install claude-code            # Install for Claude Code
nlm skill install cursor                 # Install for Cursor AI
nlm skill install <tool> --level project # Install at project level
nlm skill uninstall <tool>               # Remove skill
nlm skill show                           # View skill content

# Verb-first alternatives
nlm install skill claude-code            
nlm list skills

# Generic/Alias targets
nlm skill install agents      # Generic name
nlm skill install codex       # Alias for OpenAI Codex CLI
nlm skill install gemini-cli   # Alias for Google Gemini CLI

# Alef Agent
nlm skill install alef-agent

To ensure high-quality outputs from Gemini Notebook Studio, all prompts (sent via focus_prompt, custom_prompt, or description) should follow a structured framework.

The Grounding Anchor

Include this in EVERY prompt to prevent hallucinations: Use only uploaded sources. Do not invent statistics, quotes, names, or examples not in the sources.

Five-Block Anatomy

For complex (Guided) prompts, use these five blocks:

1. Audience: Who consumes this (e.g., "Non-technical executives").
2. Goal: The desired outcome (e.g., "Prep for midterm on thermodynamics").
3. Scope: What to include or exclude (e.g., "Chapter 4 only; skip historical background").
4. Structure: Sections, beats, or layout (e.g., "Problem → 3 findings → recommendation").
5. Constraints: Tone, length, or language (e.g., "Conversational; ~10 min; English only").

Prompt Templates

Fast-track minimal (1–3 sentences): [Audience]. Focus on [2-3 themes from sources]. [Structure or tone hint]. Use only uploaded sources.

Guided full skeleton: Audience: [who]. Goal: [outcome]. Focus: [themes]. Exclude: [skip]. Structure: [sections]. Tone: [register]. Use only uploaded sources.

When automating Gemini Notebook via CLI or MCP, adhere to these rules:

1. Mandatory Confirmation for Deletions: Always ask the user for explicit confirmation before executing any delete command. Deletions are irreversible.
2. Mandatory Approval for Generation: Always obtain approval before triggering studio_create or deletion operations. Even if the tool has a confirm=True parameter, the agent must maintain an approval gate.
3. Avoid REPLs: Do NOT use nlm chat start. It opens an interactive REPL that cannot be controlled by AI tools. Use nlm notebook query for one-shot Q&A instead.
4. Capture IDs: Commands that create or start processes return IDs. You must capture these IDs to use them in subsequent operations (e.g., passing --notebook-id <id>).
5. Use Aliases for Convenience: Use nlm alias set <name> <uuid> to simplify long UUIDs, and check nlm alias list before creating new ones to avoid conflicts.

To enable multi-user isolation in Open WebUI, create a custom Function that injects the Open WebUI __user__ context into MCP calls. This ensures that each user's conversation history is isolated even when using a shared Gemini Notebook account.

Implementation Steps:

1. Navigate to Workspace → Functions → Create in Open WebUI.
2. Paste the Python function implementation (see code example).
3. Save and enable the function.

Note: The function relies on Open WebUI's ability to automatically inject a __user__ dictionary containing id, email, name, and role into the function call.

import httpx

class Tools:
    def __init__(self):
        # Adjust to your MCP server URL
        self.mcp_url = "http://localhost:8000"
    
    async def query_notebook(
        self, 
        notebook_id: str, 
        question: str, 
        __user__: dict = {}
    ) -> str:
        """Ask a question about a NotebookLM notebook."""
        user_id = __user__.get("id", "anonymous")
        
        async with httpx.AsyncClient(timeout=120) as client:
            response = await client.post(
                f"{self.mcp_url}/mcp",
                json={
                    "tool": "notebook_query",
                    "arguments": {
                        "notebook_id": notebook_id,
                        "query": question,
                        "user_id": user_id,
                    }
                }
            )
            result = response.json()
            if result.get("status") == "success":
                return result.get("answer", "No answer generated")
            else:
                return f"Error: {result.get('error', 'Unknown error')}"

    # Additional methods like list_notebooks, new_conversation, and check_rate_limit 
    # follow the same pattern of extracting user_id from __user__.