Skip to content

amitdevv/NoobBook

BranchesTags
 
 

Repository files navigation

NoobBook

NoobBook Logo

NotebookLM, but smarter.

An open-source NotebookLM alternative. Free to use, fork, and self-host.

noobbooklm.com

First Believer & Primary Sponsor

Delta Exchange

Thank you Delta Exchange for believing in NoobBook from day one.

Want to sponsor? See how

Special Thanks

GrowthX

GrowthX - The community that helped shape this journey.

Built with: Claude & Claude Code | OpenAI | ElevenLabs | Pinecone | Tavily | Google AI

Powered by open-source: React | Vite | Flask | shadcn/ui | Tailwind CSS | Radix UI

Table of Contents

What is NoobBook?

NoobBook is a fully-featured NotebookLM alternative that you can run yourself. Upload documents, chat with your sources using RAG, and generate content with AI agents.

Core Features:

  • Multi-modal source ingestion (PDF, DOCX, PPTX, images, audio, YouTube, URLs)
  • RAG-powered chat with citations
  • AI-generated content (audio overviews, mind maps, presentations, and more)
  • Memory system for personalized responses
  • Voice input and text-to-speech

How It Works

NoobBook has 4 main concepts:

1. Projects

Everything is organized into projects. Each project has its own sources, chats, and studio outputs.

2. Sources (Left Panel)

Upload documents and the system processes them for AI understanding:

Source Type Processing
PDF AI vision extracts text page by page
DOCX Python extraction
PPTX Convert to PDF, then vision extraction
Images AI vision describes content
Audio ElevenLabs transcription
YouTube Transcript API
URLs Web agent fetches and extracts content
Text Direct input

Processing Pipeline:

Upload -> Raw file saved -> AI extracts text -> Chunked for RAG -> Embedded in Pinecone

3. Chat (Center Panel)

RAG-powered Q&A with your sources:

User question
    -> AI searches relevant sources (hybrid: keyword + semantic)
    -> AI generates response with citations
    -> Citations link to specific chunks

Key features:

  • Chunk-based citations
  • Memory system (user preferences + project context)
  • Voice input via ElevenLabs
  • Conversation history per chat

4. Studio (Right Panel)

Generate content from your sources using AI agents:

Category Studio Items
Audio/Video Audio Overview, Video Generation
Learning Flash Cards, Mind Maps, Quizzes
Documents PRD, Blog Posts, Business Reports, Presentations
Marketing Ad Creatives, Social Posts, Email Templates
Design Websites, Components, Wireframes, Flow Diagrams

Architecture

Frontend (React + Vite)
    |
    v
Backend API (Flask + SocketIO)
    |
    ├── Source Processing (upload, extract, chunk, embed)
    ├── Chat Service (RAG search, Claude API, citations)
    ├── Studio Services (content generation agents)
    └── Integrations (Claude, OpenAI, Pinecone, ElevenLabs, Gemini)
    |
    v
Supabase (PostgreSQL + S3 Storage + Auth)

AI Services:

  • Claude - Main LLM for chat, agents, content generation
  • OpenAI - Embeddings for vector search
  • Pinecone - Vector database for RAG
  • ElevenLabs - Text-to-speech and transcription
  • Gemini - Image generation
  • Google Veo - Video generation

Getting Started (Docker Setup)

Docker is the recommended way to run NoobBook. One script starts everything — Supabase, PostgreSQL, database migrations, backend, and frontend (16 containers total).

Prerequisites

Before you begin, make sure you have:

Requirement Install Check
Docker Desktop docs.docker.com/get-docker docker info
Docker Compose v2 Included with Docker Desktop docker compose version
Python 3 brew install python3 (macOS) / sudo apt install python3 (Ubuntu) python3 --version

Important: Docker Desktop must be running (not just installed). Open it from your Applications before running setup.

Ports required (must be free):

Port Used by
80 NoobBook frontend (nginx)
5001 NoobBook backend API
8000 Supabase API gateway
5432 PostgreSQL

The setup script checks these automatically and will tell you if something is already using a port.

API Keys

Get these before running setup:

Key Where to get it Required?
ANTHROPIC_API_KEY console.anthropic.com Yes
OPENAI_API_KEY platform.openai.com Yes
PINECONE_API_KEY + PINECONE_INDEX_NAME pinecone.io Yes
ELEVENLABS_API_KEY elevenlabs.io No — audio features
TAVILY_API_KEY tavily.com No — web search fallback
GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET Google Cloud Console No — Google Drive import
JIRA_CLOUD_ID (or JIRA_DOMAIN) + JIRA_EMAIL + JIRA_API_KEY Jira Settings → Security → API tokens No — Jira integration
NOTION_API_KEY Notion Integrations No — Notion integration
NANO_BANANA_API_KEY Google AI Studio No — Gemini image generation
VEO_API_KEY Google AI Studio No — Video generation

Step 1: Clone and Configure

# Clone the repo
git clone https://github.com/TeacherOp/NoobBook.git
cd NoobBook
git checkout develop

# Copy env template
cp docker/.env.example docker/.env

Edit docker/.env and add your API keys:

nano docker/.env

At minimum, fill in these four:

ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
PINECONE_API_KEY=...
PINECONE_INDEX_NAME=...

Step 2: Set Up Auth (Required)

Auth is enabled by default. You need to configure an admin account before running setup.

In docker/.env, set your admin credentials:

# Admin email(s) — these users get admin role on signup
NOOBBOOK_ADMIN_EMAILS=you@company.com

# Bootstrap admin — auto-creates this admin account on startup
NOOBBOOK_BOOTSTRAP_ADMIN_EMAIL=admin@example.com
NOOBBOOK_BOOTSTRAP_ADMIN_PASSWORD=YourSecurePassword123!

How it works: The bootstrap admin is created automatically when the app starts. You'll use these credentials to log in at http://localhost. Any other user who signs up gets the user role (can chat, use studio, manage projects). Admins can additionally manage app settings and API keys.

Step 3: Run Setup

bash docker/setup.sh

This will:

  1. Check prerequisites (Docker running, ports free, python3 available)
  2. Generate Supabase secrets (JWT tokens, database passwords)
  3. Create the Docker network
  4. Start Supabase services (PostgreSQL, Auth, Storage, API gateway)
  5. Build and start NoobBook (backend, frontend, database migration)

First run takes 3-5 minutes (downloading images + building). Subsequent runs are faster (cached).

Already ran setup before? If you've previously set up NoobBook and something isn't working, do a full reset first so everything starts fresh:

bash docker/reset.sh -v
bash docker/setup.sh

When you see this, you're good:

============================================
  NoobBook is running!
============================================

  App:              http://localhost
  Supabase Studio:  http://localhost:8000

Step 4: Log In

Open http://localhost and sign in with the bootstrap admin credentials you set in Step 2.

Auth & Roles (RBAC)

NoobBook has two roles:

  • admin — can view/update API keys, manage app settings, plus everything a user can do
  • user — can chat, use studio, upload sources, and manage projects

Auth settings in docker/.env:

Variable Description
NOOBBOOK_AUTH_REQUIRED=true Requires login for all API routes (default: true)
NOOBBOOK_ADMIN_EMAILS=a@b.com,c@d.com These emails get admin role on signup
NOOBBOOK_BOOTSTRAP_ADMIN_EMAIL Auto-creates this admin on startup
NOOBBOOK_BOOTSTRAP_ADMIN_PASSWORD Password for the bootstrap admin
NOOBBOOK_BOOTSTRAP_ADMIN_FORCE_RESET=true Reset the bootstrap admin password if account already exists

First signup rule: If no admins exist yet, the first user to sign up automatically becomes admin (even without being in NOOBBOOK_ADMIN_EMAILS).

Managing Your Setup

Stopping and starting:

bash docker/stop.sh           # Stop all services (your data is preserved)
bash docker/setup.sh          # Start again (safe to re-run, uses existing config)

Full reset (destructive — deletes all data):

bash docker/reset.sh -v       # Stops everything + deletes database, storage, and .env files
bash docker/setup.sh          # Fresh start with new secrets

Note on re-running setup.sh: The script is idempotent — it detects existing .env files and reuses them. Your Supabase secrets, database passwords, and API keys are not regenerated on subsequent runs. If you need fresh secrets (e.g. something is broken), do a full reset first with reset.sh -v.

If something goes wrong:

# Check container status
docker ps --format "table {{.Names}}\t{{.Status}}"

# Check logs for a specific service
docker logs noobbook-backend
docker logs supabase-db
docker logs supabase-kong

# Nuclear option — wipe everything and start fresh
bash docker/reset.sh -v
bash docker/setup.sh
Command What it does
bash docker/setup.sh Start everything (idempotent, safe to re-run)
bash docker/stop.sh Stop all services, keep data
bash docker/reset.sh Stop all services, remove network
bash docker/reset.sh -v Stop + delete ALL data (database, storage, .env files)
Service URL
NoobBook App http://localhost
Supabase Studio http://localhost:8000
MinIO Console http://localhost:9001

Note: All API traffic is routed through nginx (/api/* → port 80). Direct backend access on port 5001 is still available by default; set BACKEND_PORT in docker/.env to change or restrict it.

Option B: Local Development

Run backend and frontend locally, but you still need Supabase running (via Docker or Supabase Cloud).

Step 1: Start Supabase

# Self-hosted via Docker
cp docker/supabase/.env.example docker/supabase/.env
# Edit docker/supabase/.env (see backend/supabase/SETUP.md for details)
docker network create noobbook-network
docker compose -f docker/supabase/docker-compose.yml --env-file docker/supabase/.env up -d

# Or use Supabase Cloud — get keys from https://app.supabase.com/project/_/settings/api

Step 2: Run database migrations

# Via psql
psql -h localhost -p 5432 -U postgres -d postgres -f backend/supabase/init.sql

# Or via Supabase Studio → SQL Editor → paste contents of init.sql → Run

Step 3: Configure environment

cp backend/.env.template backend/.env
nano backend/.env

Add your API keys AND Supabase keys:

# Required API keys
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
PINECONE_API_KEY=...
PINECONE_INDEX_NAME=...

# Required Supabase keys (app won't start without these)
SUPABASE_URL=http://localhost:8000
SUPABASE_ANON_KEY=your-anon-key
SUPABASE_SERVICE_KEY=your-service-role-key

Step 4: Install and run

macOS / Linux:

bin/setup                     # First time — creates venv, installs all deps
bin/dev                       # Starts backend (:5001) + frontend (:5173)

# Options
bin/dev --backend-only        # Only Flask server
bin/dev --frontend-only       # Only Vite server
bin/dev --install             # Update deps before starting

Windows:

cd backend
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt

cd ..\frontend
npm install

cd ..
python start.py               # Starts both servers (run from repo root)
python stop.py                 # Stops both servers

Step 5: Install Playwright (for web scraping)

npx playwright install

For the full Supabase setup guide, see backend/supabase/SETUP.md.

Tech Stack

Layer Technology
Frontend React + Vite + TypeScript
UI shadcn/ui + Tailwind CSS
Icons Phosphor Icons
Backend Python Flask + SocketIO
Database Supabase (PostgreSQL + S3 Storage + Auth)
AI/LLM Claude (Anthropic), OpenAI Embeddings
Vector DB Pinecone
Audio ElevenLabs
Image Gen Google Gemini
Video Gen Google Veo 2.0

Contributing

Contributions welcome!

Branch strategy:

  • main - Stable branch for testing and using NoobBook
  • develop - Latest changes, all PRs go here

Quick start:

  1. Fork the repo
  2. Pull from develop
  3. Create your branch
  4. Open a PR to develop (not main)

See CONTRIBUTING.md for full details and CLAUDE.md for code guidelines.

License

This project is licensed under the MIT License.

Copyright (c) 2026 Neel Seth / TeacherOp

Built with a $10,000 USD sponsorship grant.

About

NoobBook the only product every company would need to run with 10x efficiency

Resources

Readme

License

MIT license

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages

  • Python 59.4%
  • TypeScript 36.6%
  • PLpgSQL 2.8%
  • Shell 0.8%
  • CSS 0.2%
  • Dockerfile 0.1%
  • Other 0.1%