Open Notebook Complete Guide: Open-Source NotebookLM Alternative That Turns PDFs, Web Pages, and Videos into AI Knowledge Bases

What Is Open Notebook?

Google NotebookLM is an AI research assistant launched by Google. It lets you upload PDFs, documents, and web pages, then chat with those materials, generate summaries, or even create podcasts. But it has one fatal flaw: all your data lives on Google's cloud, and you're stuck using only Google's proprietary Gemini models.

Open Notebook is a fully open-source, self-hostable alternative to NotebookLM, led by developer lfnovo. Its core philosophy is simple: knowledge management shouldn't be monopolized by big tech companies, and it shouldn't come at the cost of your privacy.

As of June 2026, Open Notebook has earned over 26,000 stars on GitHub, gaining hundreds of new stars daily. It's one of the hottest open-source AI tools right now.

Open Notebook vs Google NotebookLM: Core Comparison

From this comparison, Open Notebook's core advantages are clear: data sovereignty and flexibility. For researchers who care about privacy, enterprise developers, or users who need customized workflows, this is a far better choice than NotebookLM.

Why Choose Open Notebook?

1. Privacy First: Your Data, Your Rules

When you use NotebookLM, every PDF, note, and conversation you upload gets stored on Google's servers. For content involving trade secrets, academic research, or personal sensitive information, this can be a security risk.

Open Notebook uses a self-hosted architecture. All data stays on your own machine or server. Paired with SurrealDB as the backend database, you have full control over where your data is stored and who can access it.

2. Support for 18+ AI Model Providers

Open Notebook integrates with major AI providers through the Esperanto library:

This means you can: - Run Llama 3 or Qwen models locally with Ollama for zero API cost and fully offline usage - Use Groq for ultra-fast inference (great for quick Q&A) - Leverage DeepSeek for cost-effective Chinese language understanding - Switch providers anytime to avoid vendor lock-in

3. Professional-Grade Podcast Generation

Open Notebook's podcast feature is more flexible than NotebookLM's:

• 1–4 speakers: Customize each character's voice, tone, and area of expertise
• Episode Profiles: Define themes, styles, and target audiences for each episode
• Script preview and editing: Review and modify scripts before generating audio
• Multilingual support: Supports English, Chinese, Japanese, Portuguese, and more

By contrast, NotebookLM's Podcast feature is locked into a two-person dialogue format (one male, one female) with a single, non-customizable style.

4. Complete REST API

Open Notebook provides a full REST API (default at http://localhost:5055/docs), supporting:

• Creating and managing Notebooks
• Uploading and processing various source types (PDFs, videos, web pages, etc.)
• Running AI-driven note generation and content transformations
• Querying chat history and context

This makes it easy to integrate Open Notebook into existing workflows, such as: - Automatically archiving Slack/Discord discussions into a Notebook - Scheduled scraping of specific websites with summary generation - Integration with CI/CD pipelines to auto-generate technical documentation summaries

Quick Start: Deploy Open Notebook in 5 Minutes

The official recommended deployment method for Open Notebook is Docker Compose. The whole process takes just two commands.

Prerequisites

• Docker Desktop installed and running
• At least 4GB of free disk space (for SurrealDB data and local cache)
• An API key from an AI provider (not needed if using local Ollama models)

Step 1: Download docker-compose.yml

curl -o docker-compose.yml https://raw.githubusercontent.com/lfnovo/open-notebook/main/docker-compose.yml

Or manually create a docker-compose.yml file:

services:
  surrealdb:
    image: surrealdb/surrealdb:v2
    command: start --log info --user root --pass root rocksdb:/mydata/mydatabase.db
    user: root
    ports:
      - "8000:8000"
    volumes:
      - ./surreal_data:/mydata
    restart: always

  open_notebook:
    image: lfnovo/open_notebook:v1-latest
    ports:
      - "8502:8502"   # Web UI
      - "5055:5055"   # REST API
    environment:
      - OPEN_NOTEBOOK_ENCRYPTION_KEY=change-me-to-a-secret-string
      - SURREAL_URL=ws://surrealdb:8000/rpc
      - SURREAL_USER=root
      - SURREAL_PASSWORD=root
      - SURREAL_NAMESPACE=open_notebook
      - SURREAL_DATABASE=open_notebook
    volumes:
      - ./notebook_data:/app/data
    depends_on:
      - surrealdb
    restart: always

Important: Change OPEN_NOTEBOOK_ENCRYPTION_KEY to your own secret string, like my-super-secret-key-2026. This key encrypts sensitive information (such as API keys) stored in the database.

Step 2: Start Services

docker compose up -d

Wait 15–20 seconds for SurrealDB to initialize, then open your browser and visit:

http://localhost:8502

You should see the Open Notebook login/registration screen.

Step 3: Configure API Keys

1. On first visit, the system will prompt you to create an admin account
2. After logging in, go to Settings → API Keys
3. Click Add Credential
4. Select your AI provider (e.g., OpenAI, Anthropic, Google, etc.)
5. Paste your API key and click Save
6. Click Test Connection to verify the connection works
7. Click Discover Models to automatically fetch available models
8. Click Register Models to complete registration

If you don't have an API key yet, you can get one from these platforms: - OpenAI - Anthropic - Google AI Studio - Groq (has a free tier)

Zero-Cost Local Run with Ollama

If you want to run completely free and offline, pair Open Notebook with Ollama:

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.ai/install.sh | sh

# Pull a lightweight model
ollama pull llama3.2:3b

# Start Ollama service
ollama serve

Then in Open Notebook's API Keys settings: 1. Add a credential, select Ollama as the provider 2. Set the URL to http://host.docker.internal:11434 (Docker accessing the host machine) 3. Test the connection and register models

Now you can use all of Open Notebook's features without paying any API fees (except TTS podcast generation, which requires an external service).

Core Features in Action

Create Your First Notebook

After logging into Open Notebook, click the + New Notebook button in the top-left corner:

1. Notebook Name: e.g., "2026 AI Technology Trends Research"
2. Description (optional): Briefly explain the purpose of this Notebook
3. Select Default Model: Choose a registered model as the default chat model
4. Click Create

Each Notebook is an independent knowledge base. You can create different Notebooks for different projects, such as: - "Python Learning Notes" - "Competitor Analysis Report" - "Product Requirements Document Library"

Add Content Sources

Open Notebook supports multiple types of content sources—one of its most powerful features.

Supported Source Types

Adding a PDF Example

1. On the Notebook page, click Add Source
2. Select Upload File
3. Drag and drop or choose a PDF file (e.g., an arXiv paper)
4. Wait for processing to complete (the system automatically extracts text and generates vector embeddings)
5. You'll see the processing status and word count in the Sources list

Adding a Web Link Example

1. Click Add Source → Web Page
2. Paste a URL, e.g., https://arxiv.org/abs/2401.12345
3. Open Notebook will automatically scrape the page and extract the body text
4. If the page has a paywall or anti-scraping measures, you may need to copy-paste content manually

Chat with Your Knowledge Base

After adding source files, you can start chatting with the AI.

On the right side of the Notebook page is the Chat panel:

1. Select Context Scope: - "All Sources": Answer based on all source files - "Selected Sources": Answer based only on selected files - "Notes Only": Answer based only on your manually written notes

2. Ask a question, for example: What are the core contributions of this paper? Summarize three key points in Chinese.

3. View Citations: AI responses include source citations. Click a citation to jump to the corresponding location in the original text

4. Save as Note: If an AI response is valuable, click Save as Note to save it as a permanent note

Generate AI-Assisted Notes

Beyond real-time chat, Open Notebook supports batch note generation:

1. On the Notebook page, click Generate Notes
2. Select the source files to process (multiple selection supported)
3. Choose a note template: - Summary: Generate a full-text summary - Key Points: Extract key takeaways - Q&A: Generate frequently asked questions and answers - Custom: Use a custom prompt
4. Click Generate and wait for AI processing to complete
5. Generated notes appear in the left-side Notes panel and can be further edited

Content Transformations

Content Transformations are an advanced Open Notebook feature that lets you execute custom AI processing actions on source files.

For example, you can create a Transformation to: - Translate all technical documents into Chinese - Extract action items from meeting notes - Compress long blog posts into 500-word summaries

Configuration steps: 1. Go to Settings → Transformations 2. Click New Transformation 3. Define a name and prompt template, for example: Please translate the following technical document into Simplified Chinese, keeping technical terminology accurate: {{content}} 4. After saving, right-click any source file and select the Transformation to execute it

Podcast Generation: Turn Notes into Audio Shows

One of Open Notebook's most distinctive features is its podcast generation capability. You can transform the content of any Notebook into a professional multi-speaker podcast.

Configure Podcast Roles

1. Go to Settings → Podcast Profiles
2. Click New Profile
3. Define roles: - Host: Guides the topic and asks questions - Expert A: Provides in-depth technical explanations - Expert B: Offers alternative perspectives or counterarguments - (Optional) Narrator: Handles opening introductions and closing summaries

Each role can be configured with: - Voice type: Male / Female / Neutral - Speech rate: Slow / Normal / Fast - Tone style: Formal / Casual / Humorous / Serious - TTS provider: OpenAI, ElevenLabs, Google, etc.

Generate a Podcast

1. On the Notebook page, click Generate Podcast
2. Select the source files and notes to include (the system automatically extracts key content)
3. Choose a podcast profile
4. Set a duration target (e.g., 10 minutes, 20 minutes)
5. Click Generate Script to preview the script
6. Review and edit the script (optional)
7. Click Generate Audio to start synthesizing the audio
8. Once complete, you can download the MP3 file or play it online

Real-World Use Cases

• Learning Review: Convert a week's worth of study notes into a podcast for your commute
• Knowledge Sharing: Create internal training audio materials for your team
• Content Repurposing: Transform blog posts into podcasts for Spotify/Apple Podcasts
• Language Learning: Generate podcasts in your target language to practice listening

REST API in Action: Automate Your Workflow

Open Notebook provides a complete REST API, running by default at http://localhost:5055. API documentation is accessible via Swagger UI at http://localhost:5055/docs.

Authentication

All API requests must carry an API Token in the Header:

curl -H "Authorization: Bearer YOUR_API_TOKEN" \
  http://localhost:5055/api/notebooks

You can generate an API Token in Settings → API Keys.

Common API Examples

1. List All Notebooks

curl -H "Authorization: Bearer $TOKEN" \
  http://localhost:5055/api/notebooks

Response:

{
  "notebooks": [
    {
      "id": "nb_abc123",
      "title": "2026 AI Technology Trends Research",
      "created_at": "2026-06-07T10:00:00Z",
      "source_count": 5,
      "note_count": 12
    }
  ]
}

2. Create a New Notebook

curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title": "New Product Research", "description": "Competitor analysis database"}' \
  http://localhost:5055/api/notebooks

3. Upload a Source File

curl -X POST -H "Authorization: Bearer $TOKEN" \
  -F "file=@research-paper.pdf" \
  -F "notebook_id=nb_abc123" \
  http://localhost:5055/api/sources/upload

4. Send a Chat Request

curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "notebook_id": "nb_abc123",
    "message": "Summarize the core arguments of this paper",
    "model": "gpt-4o",
    "temperature": 0.7
  }' \
  http://localhost:5055/api/chat

Python Client Example

import requests

BASE_URL = "http://localhost:5055/api"
TOKEN = "your_api_token_here"
headers = {"Authorization": f"Bearer {TOKEN}"}

# Get all Notebooks
response = requests.get(f"{BASE_URL}/notebooks", headers=headers)
notebooks = response.json()["notebooks"]

for nb in notebooks:
    print(f"Notebook: {nb['title']} ({nb['source_count']} sources)")

# Create a new Notebook
new_nb = requests.post(
    f"{BASE_URL}/notebooks",
    headers=headers,
    json={"title": "Test Notebook", "description": "API test"}
)
print(f"Created: {new_nb.json()['id']}")

With the REST API, you can integrate Open Notebook into existing automation workflows, such as: - Scheduled RSS feed scraping to auto-generate article summaries - Automatic archiving of Slack channel discussions into a Notebook - Integration with CI/CD pipelines to auto-generate technical impact analyses of code changes

Advanced Configuration

Password Protection for Public Deployments

If you deploy Open Notebook on a public server, enable password protection:

Add an environment variable in docker-compose.yml:

open_notebook:
  environment:
    - OPEN_NOTEBOOK_PASSWORD=my-secure-password

After restarting the service, you'll need to enter a password to access the Web UI.

Custom Domain and HTTPS

Use Nginx as a reverse proxy to enable custom domains and HTTPS:

server {
    listen 443 ssl;
    server_name notebook.example.com;

    ssl_certificate /etc/letsencrypt/live/notebook.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/notebook.example.com/privkey.pem;

    location / {
        proxy_pass http://localhost:8502;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /api/ {
        proxy_pass http://localhost:5055/api/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Data Backup

Open Notebook stores data in two directories: - ./surreal_data/: SurrealDB database files - ./notebook_data/: Uploaded source files and cache

Regularly back up these two directories:

# Create backup
tar czf open-notebook-backup-$(date +%Y%m%d).tar.gz \
  surreal_data/ notebook_data/

# Restore backup
tar xzf open-notebook-backup-20260607.tar.gz

Troubleshooting Common Issues

1. Cannot Access Web UI After Docker Container Starts

Symptom: docker compose up -d succeeds, but http://localhost:8502 is unreachable

Solution:

# Check container status
docker compose ps

# View logs
docker compose logs open_notebook
docker compose logs surrealdb

# If SurrealDB isn't ready, wait 30 seconds and retry
docker compose restart

2. API Key Connection Test Fails

Symptom: Testing OpenAI/Anthropic connection in Settings shows an error

Solution: - Confirm the API key is correct and not expired - Check your network connection (some regions may require a proxy) - Check Docker logs for SSL or timeout errors - Try calling the API directly from the host machine to verify the key

3. Ollama Models Not Discovered

Symptom: After adding Ollama credentials, Discover Models returns an empty list

Solution:

# Confirm Ollama is running
ollama list

# Test connection from inside Docker
docker exec -it <open_notebook_container_id> curl http://host.docker.internal:11434/api/tags

# If connection fails, check Docker network configuration
# macOS/Docker Desktop supports host.docker.internal by default
# Linux may require additional configuration

4. PDF Processing Fails or Returns Empty Content

Symptom: After uploading a PDF, the Source shows "processed" but word count is 0

Solution: - Confirm the PDF is not a scanned document (scanned PDFs require OCR, which Open Notebook doesn't currently support) - Try opening the PDF in another reader to confirm text is selectable - Check Docker logs for out-of-memory errors - Large files (>50MB) may require increasing Docker memory limits

5. Poor Podcast Audio Quality

Symptom: Generated podcast voices sound robotic or unnatural

Solution: - Switch to a higher-quality TTS provider (e.g., ElevenLabs) - Adjust speech rate and tone parameters in the role profile - Ensure the selected TTS model supports the target language - Check that your API quota is sufficient

Summary

Open Notebook is currently the most mature open-source alternative to NotebookLM. It surpasses Google's native product in several key areas:

1. Data Sovereignty: Self-hosted architecture ensures your research data remains fully private
2. Model Freedom: Supports 18+ AI providers, avoiding vendor lock-in
3. Rich Features: Professional-grade podcast generation, REST API, custom transformation actions
4. Controllable Costs: Optional local Ollama for zero API costs
5. Open and Transparent: Apache 2.0 license, community-driven development

For privacy-conscious researchers, developers who need customizable workflows, or knowledge workers who simply want to break free from big-tech monopolies, Open Notebook is a tool worth investing time in.

Next Steps: - Visit the GitHub repository to stay updated - Join the Discord community to connect with other users - Read the official documentation for more detailed tutorials - Deploy locally and create your first Notebook

This article was written based on Open Notebook v1. The project is under continuous iteration; refer to the latest version for current features.