Open Notebook

Open Notebook is an open-source, privacy-focused alternative to Google's Notebook LM, designed to empower users with secure and customizable knowledge management.

Join our Discord server for assistance, workflow discussions, and feature suggestions. Visit our website to learn more.

Overview

Open Notebook offers a private, multi-model, 100% local, and full-featured alternative to traditional knowledge management tools.

In an AI-dominated world, the ability to think, learn, and acquire new knowledge should be accessible to all, not a privilege or restricted to a single provider. Open Notebook provides you with these capabilities:

• Control Your Data: Keep your research private and secure with self-hosting.
• Choose Your AI Models: Support for over 16 providers, including OpenAI, Anthropic, Ollama, and LM Studio.
• Organize Multi-Modal Content: Seamlessly integrate PDFs, videos, audio, web pages, and other content types.
• Generate Professional Podcasts: Create advanced multi-speaker podcasts.
• Intelligent Search: Utilize full-text and vector search across all your content.
• Chat with Context: Engage in AI conversations powered by your own research.

Learn more about our project at https://www.open-notebook.ai.

Important: v1.0 Breaking Changes

If you are upgrading from a previous version, please be aware of the following critical changes:

• Docker Tags Updated: The latest Docker tag is now frozen to the last Streamlit version. For the new React/Next.js version, use the recommended v1-latest tag.
• Port 5055 Requirement: Port 5055 must be exposed for the API to function correctly.
• Migration Guide: Refer to MIGRATION.md for detailed upgrade instructions.

New users can disregard this notice and proceed with the Quick Start guide below using the v1-latest-single tag.

Open Notebook vs. Google Notebook LM

Feature	Open Notebook	Google Notebook LM	Advantage
Privacy & Control	Self-hosted, complete data sovereignty	Google cloud only	Complete data sovereignty
AI Provider Choice	16+ providers (OpenAI, Anthropic, Ollama, LM Studio)	Google models only	Flexibility and cost optimization
Podcast Speakers	1-4 speakers with custom profiles	2 speakers only	Extreme flexibility
Context Control	3 granular levels	All-or-nothing	Privacy and performance tuning
Content Transformations	Custom and built-in	Limited options	Unlimited processing power
API Access	Full REST API	No API	Complete automation
Deployment	Docker, cloud, or local	Google hosted only	Deploy anywhere
Citations	Comprehensive with sources	Basic references	Research integrity
Customization	Open source, fully customizable	Closed system	Unlimited extensibility
Cost	Pay only for AI usage	Monthly subscription + usage	Transparent and controllable

Why Choose Open Notebook?

• Privacy First: Your sensitive research remains entirely private.
• Cost Control: Opt for more affordable AI providers or run models locally with Ollama.
• Superior Podcasts: Enjoy full script control and multi-speaker flexibility, surpassing the limitations of a 2-speaker deep-dive format.
• Unlimited Customization: Modify, extend, and integrate the platform as needed.
• No Vendor Lock-in: Switch providers, deploy anywhere, and maintain ownership of your data.

Technologies Used

Open Notebook is built with Python, Next.js, React, SurrealDB, and LangChain.

Quick Start

Docker Images Available:

• Docker Hub: lfnovo/open_notebook:v1-latest-single
• GitHub Container Registry: ghcr.io/lfnovo/open-notebook:v1-latest-single

Both registries offer identical images; choose your preferred source.

Choose Your Setup:

Local Machine Setup

Ideal if Docker runs on the same computer where you will access Open Notebook.

mkdir open-notebook && cd open-notebook

docker run -d \\
  --name open-notebook \\
  -p 8502:8502 -p 5055:5055 \\
  -v ./notebook_data:/app/data \\
  -v ./surreal_data:/mydata \\
  -e OPENAI_API_KEY=your_key_here \\
  -e SURREAL_URL=\"ws://localhost:8000/rpc\" \\
  -e SURREAL_USER=\"root\" \\
  -e SURREAL_PASSWORD=\"root\" \\
  -e SURREAL_NAMESPACE=\"open_notebook\" \\
  -e SURREAL_DATABASE=\"production\" \\
  lfnovo/open_notebook:v1-latest-single

Access Open Notebook at: http://localhost:8502

Remote Server Setup

Use this setup for servers, Raspberry Pi, NAS, Proxmox, or any remote machine.

mkdir open-notebook && cd open-notebook

docker run -d \\
  --name open-notebook \\
  -p 8502:8502 -p 5055:5055 \\
  -v ./notebook_data:/app/data \\
  -v ./surreal_data:/mydata \\
  -e OPENAI_API_KEY=your_key_here \\
  -e API_URL=http://YOUR_SERVER_IP:5055 \\
  -e SURREAL_URL=\"ws://localhost:8000/rpc\" \\
  -e SURREAL_USER=\"root\" \\
  -e SURREAL_PASSWORD=\"root\" \\
  -e SURREAL_NAMESPACE=\"open_notebook\" \\
  -e SURREAL_DATABASE=\"production\" \\
  lfnovo/open_notebook:v1-latest-single

Replace YOUR_SERVER_IP with your server's actual IP address (e.g., 192.168.1.100) or domain.

Access Open Notebook at: http://YOUR_SERVER_IP:8502

Critical Setup Notes:

• Both Ports Required:
  • Port 8502: Serves the web interface (what you see in your browser).
  • Port 5055: Required for the API backend to function.
• API_URL Must Match Access Method: The API_URL environment variable must reflect how you access the server.
  • Correct: Access via http://192.168.1.100:8502 → set API_URL=http://192.168.1.100:5055
  • Correct: Access via http://myserver.local:8502 → set API_URL=http://myserver.local:5055
  • Incorrect: Do not use localhost for remote servers; it will not work from other devices!

Using Docker Compose (Recommended for Easy Management)

Create a docker-compose.yml file:

services:
  open_notebook:
    image: lfnovo/open_notebook:v1-latest-single
    # Or use: ghcr.io/lfnovo/open-notebook:v1-latest-single
    ports:
      - \"8502:8502\" # Web UI
      - \"5055:5055\" # API (required!)
    environment:
      - OPENAI_API_KEY=your_key_here
      # For remote access, uncomment and set your server IP/domain:
      # - API_URL=http://192.168.1.100:5055
      # Database connection (required for single-container)
      - SURREAL_URL=ws://localhost:8000/rpc
      - SURREAL_USER=root
      - SURREAL_PASSWORD=root
      - SURREAL_NAMESPACE=open_notebook
      - SURREAL_DATABASE=production
    volumes:
      - ./notebook_data:/app/data
      - ./surreal_data:/mydata
    restart: always

Start with:

docker compose up -d

This will create the following directory structure:

open-notebook/ ├── docker-compose.yml # Your configuration ├── notebook_data/ # Your notebooks and research content └── surreal_data/ # Database files

Quick Troubleshooting

Problem	Solution
"Unable to connect to server"	Set API_URL environment variable to match how you access the server.
Blank page or errors	Ensure both ports (8502 and 5055) are exposed in your Docker command.
Works on server but not from other computers	Do not use localhost in API_URL; use your server's actual IP address.
"404" or "config endpoint" errors	Do not append /api to API_URL; use just http://your-ip:5055.

Still experiencing issues? Check our 5-minute troubleshooting guide or join our Discord server.

How Open Notebook Works

Open Notebook operates with a clear architecture:

┌─────────────────────────────────────────────────────────┐ │ Your Browser │ │ Access: http://your-server-ip:8502 │ └────────────────┬────────────────────────────────────────┘ │ ▼ ┌───────────────┐ │ Port 8502 │ ← Next.js Frontend (what you see) │ Frontend │ Also proxies API requests internally! └───────┬───────┘ │ proxies /api/* requests ↓ ▼ ┌───────────────┐ │ Port 5055 │ ← FastAPI Backend (handles requests) │ API │ └───────┬───────┘ │ ▼ ┌───────────────┐ │ SurrealDB │ ← Database (internal, auto-configured) │ (Port 8000) │ └───────────────┘

Key Points:

• v1.1+: The Next.js frontend automatically proxies /api/* requests to the backend, simplifying reverse proxy configurations.
• Your browser loads the frontend from port 8502.
• The frontend requires knowledge of the API's location. When accessing remotely, set: API_URL=http://your-server-ip:5055.
• If deploying behind a reverse proxy, you only need to proxy to port 8502. Refer to the Reverse Proxy Guide.

Full Installation

For development or custom configurations, follow these steps:

git clone https://github.com/lfnovo/open-notebook
cd open-notebook
make start-all

Need Help?

• AI Installation Assistant: Utilize our CustomGPT designed to guide you through the Open Notebook installation process.
• New to Open Notebook?: Begin with our Getting Started Guide.
• Installation Assistance: Consult our Installation Guide.
• See it in Action: Try our Quick Start Tutorial.

Provider Support Matrix

Thanks to the Esperanto library, Open Notebook supports a wide range of providers out-of-the-box:

Provider	LLM Support	Embedding Support	Speech-to-Text	Text-to-Speech
OpenAI	✅	✅	✅	✅
Anthropic	✅	❌	❌	❌
Groq	✅	❌	✅	❌
Google (GenAI)	✅	✅	❌	✅
Vertex AI	✅	✅	❌	✅
Ollama	✅	✅	❌	❌
Perplexity	✅	❌	❌	❌
ElevenLabs	❌	❌	✅	✅
Azure OpenAI	✅	✅	❌	❌
Mistral	✅	✅	❌	❌
DeepSeek	✅	❌	❌	❌
Voyage	❌	✅	❌	❌
xAI	✅	❌	❌	❌
OpenRouter	✅	❌	❌	❌
OpenAI Compatible*	✅	❌	❌	❌

*Supports LM Studio and any OpenAI-compatible endpoint.

Key Features

Core Capabilities

• Privacy-First: Your data remains under your control, free from cloud dependencies.
• Multi-Notebook Organization: Manage numerous research projects seamlessly.
• Universal Content Support: Ingest PDFs, videos, audio, web pages, Office documents, and more.
• Multi-Model AI Support: Integrate with over 16 AI providers, including OpenAI, Anthropic, Ollama, Google, and LM Studio.
• Professional Podcast Generation: Create advanced multi-speaker podcasts with customizable Episode Profiles.
• Intelligent Search: Perform full-text and vector searches across all your content.
• Context-Aware Chat: Engage in AI conversations informed by your research materials.
• AI-Assisted Notes: Generate insights or create notes manually.

Advanced Features

• Reasoning Model Support: Full compatibility with advanced reasoning models like DeepSeek-R1 and Qwen3.
• Content Transformations: Utilize powerful, customizable actions to summarize and extract insights from your content.
• Comprehensive REST API: Gain full programmatic access for custom integrations.
• Optional Password Protection: Secure public deployments with built-in authentication.
• Fine-Grained Context Control: Precisely choose what information to share with AI models.
• Citations: Obtain answers with proper source citations for research integrity.

Three-Column Interface

The intuitive interface is structured into three main columns:

• Sources: Manage all your research materials.
• Notes: Create manual or AI-generated notes.
• Chat: Converse with AI using your content as context.

Documentation

Getting Started

• Introduction: Learn about Open Notebook's capabilities.
• Quick Start: Get up and running in 5 minutes.
• Installation: A comprehensive setup guide.
• Your First Notebook: A step-by-step tutorial.

User Guide

• Interface Overview: Understand the application's layout.
• Notebooks: Organize your research projects.
• Sources: Manage various content types.
• Notes: Create and manage your notes.
• Chat: Engage in AI conversations.
• Search: Efficiently find information within your content.

Advanced Topics

• Podcast Generation: Create professional podcasts.
• Content Transformations: Customize content processing workflows.
• AI Models: Configure your AI models.
• REST API Reference: Complete documentation for the API.
• Security: Information on password protection and privacy.
• Deployment: Comprehensive guides for various deployment scenarios.

Roadmap

Upcoming Features

• Live Front-End Updates: Real-time UI updates for a smoother user experience.
• Async Processing: Faster UI through asynchronous content processing.
• Cross-Notebook Sources: Reuse research materials across multiple projects.
• Bookmark Integration: Connect with your favorite bookmarking applications.

Recently Completed

• Next.js Frontend: Modern React-based frontend with improved performance.
• Comprehensive REST API: Full programmatic access to all functionality.
• Multi-Model Support: Integrated 16+ AI providers including OpenAI, Anthropic, Ollama, and LM Studio.
• Advanced Podcast Generator: Professional multi-speaker podcasts with Episode Profiles.
• Content Transformations: Powerful, customizable actions for content processing.
• Enhanced Citations: Improved layout and finer control for source citations.
• Multiple Chat Sessions: Manage different conversations within notebooks.

For a complete list of proposed features and known issues, please refer to the open issues on GitHub.

Community & Contributing

Join the Community

• Discord Server: Get help, share ideas, and connect with other users.
• GitHub Issues: Report bugs and request features.
• Star the Repository: Show your support and help others discover Open Notebook.

Contributing

We welcome contributions and are actively seeking help with:

• Frontend Development: Enhance our modern Next.js/React user interface.
• Testing & Bug Fixes: Improve Open Notebook's robustness and stability.
• Feature Development: Collaborate to build the next generation of research tools.
• Documentation: Improve guides and tutorials for clarity and completeness.

Current Tech Stack: Python, FastAPI, Next.js, React, SurrealDB.

Future Roadmap Focus: Real-time updates and enhanced asynchronous processing.

Refer to our Contributing Guide for detailed information on how to get started.

License

Open Notebook is MIT licensed.

Contact

• Creator: Luis Novo (@lfnovo)
• Community Support:
  • Discord Server
  • GitHub Issues
  • Website

Acknowledgments

Open Notebook is built upon the foundation of remarkable open-source projects:

• Podcast Creator - For advanced podcast generation capabilities.
• Surreal Commands - For background job processing.
• Content Core - For content processing and management.
• Esperanto - For multi-provider AI model abstraction.
• Docling - For document processing and parsing.