Open Notebook

Open Notebook

Overview

Open Notebook is an open-source, self-hosted alternative to Google's NotebookLM that enables researchers to organize materials, generate AI-powered insights, create podcasts, and have context-aware conversations with their documents — all while maintaining complete data privacy.

Unlike Google's Notebook LM, which has no publicly available API outside of the Enterprise version, Open Notebook provides a comprehensive REST API, supports 16+ AI providers, and runs entirely on your own infrastructure.

Key advantages over NotebookLM:

• Full REST API for programmatic access and automation
• Choice of 16+ AI providers (not locked to Google models)
• Multi-speaker podcast generation with 1-4 customizable speakers (vs. 2-speaker limit)
• Complete data sovereignty through self-hosting
• Open source and fully extensible (MIT license)

Repository: https://github.com/lfnovo/open-notebook

Quick Start

Prerequisites

• Docker Desktop installed
• API key for at least one AI provider (or local Ollama for free local inference)

Installation

Deploy Open Notebook using Docker Compose:

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

# Set the required encryption key
export OPEN_NOTEBOOK_ENCRYPTION_KEY="your-secret-key-here"

# Launch the services
docker-compose up -d

Access the application:

• Frontend UI: http://localhost:8502
• REST API: http://localhost:5055
• API Documentation: http://localhost:5055/docs

Configure AI Provider

After startup, configure at least one AI provider:

1. Navigate to Settings > API Keys in the UI 2. Add credentials for your preferred provider (OpenAI, Anthropic, etc.) 3. Test the connection and discover available models 4. Register models for use across the platform

Or configure via the REST API:

import requests

BASE_URL = "http://localhost:5055/api"

# Add a credential for an AI provider
response = requests.post(f"{BASE_URL}/credentials", json={
    "provider": "openai",
    "name": "My OpenAI Key",
    "api_key": "sk-..."
})
credential = response.json()

# Discover available models
response = requests.post(
    f"{BASE_URL}/credentials/{credential['id']}/discover"
)
discovered = response.json()

# Register discovered models
requests.post(
    f"{BASE_URL}/credentials/{credential['id']}/register-models",
    json={"model_ids": [m["id"] for m in discovered["models"]]}
)

Core Features

Notebooks

Organize research into separate notebooks, each containing sources, notes, and chat sessions.

import requests

BASE_URL = "http://localhost:5055/api"

# Create a notebook
response = requests.post(f"{BASE_URL}/notebooks", json={
    "name": "Cancer Genomics Research",
    "description": "Literature review on tumor mutational burden"
})
notebook = response.json()
notebook_id = notebook["id"]

Sources

Ingest diverse content types including PDFs, videos, audio files, web pages, and Office documents. Sources are processed for full-text and vector search.

# Add a web URL source
response = requests.post(f"{BASE_URL}/sources", data={
    "url": "https://arxiv.org/abs/2301.00001",
    "notebook_id": notebook_id,
    "process_async": "true"
})
source = response.json()

# Upload a PDF file
with open("paper.pdf", "rb") as f:
    response = requests.post(
        f"{BASE_URL}/sources",
        data={"notebook_id": notebook_id},
        files={"file": ("paper.pdf", f, "application/pdf")}
    )

Notes

Create and manage notes (human or AI-generated) associated with notebooks.

# Create a human note
response = requests.post(f"{BASE_URL}/notes", json={
    "title": "Key Findings",
    "content": "TMB correlates with immunotherapy response in NSCLC...",
    "note_type": "human",
    "notebook_id": notebook_id
})

Context-Aware Chat

Chat with your research materials using AI that cites sources.

# Create a chat session
session = requests.post(f"{BASE_URL}/chat/sessions", json={
    "notebook_id": notebook_id,
    "title": "TMB Discussion"
}).json()

# Send a message with context from sources
response = requests.post(f"{BASE_URL}/chat/execute", json={
    "session_id": session["id"],
    "message": "What are the key biomarkers for immunotherapy response?",
    "context": {"include_sources": True, "include_notes": True}
})

Search

Search across all materials using full-text or vector (semantic) search.

# Vector search across the knowledge base
results = requests.post(f"{BASE_URL}/search", json={
    "query": "tumor mutational burden immunotherapy",
    "search_type": "vector",
    "limit": 10
}).json()

# Ask a question with AI-powered answer
answer = requests.post(f"{BASE_URL}/search/ask/simple", json={
    "query": "How does TMB predict checkpoint inhibitor response?"
}).json()

Podcast Generation

Generate professional multi-speaker podcasts from research materials with 1-4 customizable speakers.

# Generate a podcast episode
job = requests.post(f"{BASE_URL}/podcasts/generate", json={
    "notebook_id": notebook_id,
    "episode_profile_id": episode_profile_id,
    "speaker_profile_ids": [speaker1_id, speaker2_id]
}).json()

# Check generation status
status = requests.get(f"{BASE_URL}/podcasts/jobs/{job['job_id']}").json()

# Download audio when ready
audio = requests.get(
    f"{BASE_URL}/podcasts/episodes/{status['episode_id']}/audio"
)

Content Transformations

Apply custom AI-powered transformations to content for summarization, extraction, and analysis.

# Create a custom transformation
transform = requests.post(f"{BASE_URL}/transformations", json={
    "name": "extract_methods",
    "title": "Extract Methods",
    "description": "Extract methodology details from papers",
    "prompt": "Extract and summarize the methodology section...",
    "apply_default": False
}).json()

# Execute transformation on text
result = requests.post(f"{BASE_URL}/transformations/execute", json={
    "transformation_id": transform["id"],
    "input_text": "...",
    "model_id": "model_id_here"
}).json()

Supported AI Providers

Open Notebook supports 16+ AI providers through the Esperanto library:

Environment Variables

Key configuration variables for Docker deployment:

API Reference

The REST API is available at http://localhost:5055/api with interactive documentation at /docs.

Core endpoint groups:

• /api/notebooks - Notebook CRUD and source association
• /api/sources - Source ingestion, processing, and retrieval
• /api/notes - Note management
• /api/chat/sessions - Chat session management
• /api/chat/execute - Chat message execution
• /api/search - Full-text and vector search
• /api/podcasts - Podcast generation and management
• /api/transformations - Content transformation pipelines
• /api/models - AI model configuration and discovery
• /api/credentials - Provider credential management

For complete API reference with all endpoints and request/response formats, see references/api_reference.md.

Architecture

Open Notebook uses a modern stack:

• Backend: Python with FastAPI
• Database: SurrealDB (document + relational)
• AI Integration: LangChain with the Esperanto multi-provider library
• Frontend: Next.js with React
• Deployment: Docker Compose with persistent volumes

Important Notes

• Open Notebook requires Docker for deployment
• At least one AI provider must be configured for AI features to work
• For free local inference without API costs, use Ollama
• The OPEN_NOTEBOOK_ENCRYPTION_KEY must be set before first launch and kept consistent across restarts
• All data is stored locally in Docker volumes for complete data sovereignty

Open Notebook API Reference

Base URL

http://localhost:5055/api

Interactive API documentation is available at http://localhost:5055/docs (Swagger UI) and http://localhost:5055/redoc (ReDoc).

Authentication

If OPEN_NOTEBOOK_PASSWORD is configured, include the password in requests. The following routes are excluded from authentication: /, /health, /docs, /openapi.json, /redoc, /api/auth/status, /api/config.

---

Notebooks

List Notebooks

GET /api/notebooks

Query Parameters:

Response: Array of notebook objects with source_count and note_count.

Create Notebook

POST /api/notebooks

Request Body:

{
  "name": "My Research",
  "description": "Optional description"
}

Get Notebook

GET /api/notebooks/{notebook_id}

Update Notebook

PUT /api/notebooks/{notebook_id}

Request Body:

{
  "name": "Updated Name",
  "description": "Updated description",
  "archived": false
}

Delete Notebook

DELETE /api/notebooks/{notebook_id}

Query Parameters:

Delete Preview

GET /api/notebooks/{notebook_id}/delete-preview

Returns counts of notes and sources that would be affected by deletion.

Link Source to Notebook

POST /api/notebooks/{notebook_id}/sources/{source_id}

Idempotent operation to associate a source with a notebook.

Unlink Source from Notebook

DELETE /api/notebooks/{notebook_id}/sources/{source_id}

---

Sources

List Sources

GET /api/sources

Query Parameters:

Create Source

POST /api/sources

Accepts multipart form data for file uploads or JSON for URL/text sources.

Form Parameters:

Create Source (JSON)

POST /api/sources/json

Legacy JSON-based endpoint for source creation.

Get Source

GET /api/sources/{source_id}

Get Source Status

GET /api/sources/{source_id}/status

Poll processing status for asynchronously ingested sources.

Update Source

PUT /api/sources/{source_id}

Request Body:

{
  "title": "Updated Title",
  "topic": "Updated topic"
}

Delete Source

DELETE /api/sources/{source_id}

Download Source File

GET /api/sources/{source_id}/download

Returns the original uploaded file.

Check Source File

HEAD /api/sources/{source_id}/download

Retry Failed Source

POST /api/sources/{source_id}/retry

Requeue a failed source for processing.

Get Source Insights

GET /api/sources/{source_id}/insights

Retrieve AI-generated insights for a source.

---

Notes

List Notes

GET /api/notes

Query Parameters:

Create Note

POST /api/notes

Request Body:

{
  "title": "My Note",
  "content": "Note content...",
  "note_type": "human",
  "notebook_id": "notebook:abc123"
}

note_type must be "human" or "ai". AI notes without titles get auto-generated titles.

Get Note

GET /api/notes/{note_id}

Update Note

PUT /api/notes/{note_id}

Request Body:

{
  "title": "Updated Title",
  "content": "Updated content",
  "note_type": "human"
}

Delete Note

DELETE /api/notes/{note_id}

---

Chat

List Sessions

GET /api/chat/sessions

Query Parameters:

Create Session

POST /api/chat/sessions

Request Body:

{
  "notebook_id": "notebook:abc123",
  "title": "Discussion Topic",
  "model_override": "optional_model_id"
}

Get Session

GET /api/chat/sessions/{session_id}

Returns session details with message history.

Update Session

PUT /api/chat/sessions/{session_id}

Delete Session

DELETE /api/chat/sessions/{session_id}

Execute Chat

POST /api/chat/execute

Request Body:

{
  "session_id": "chat_session:abc123",
  "message": "Your question here",
  "context": {
    "include_sources": true,
    "include_notes": true
  },
  "model_override": "optional_model_id"
}

Build Context

POST /api/chat/context

Build contextual data from sources and notes for a chat session.

---

Search

Search Knowledge Base

POST /api/search

Request Body:

{
  "query": "search terms",
  "search_type": "vector",
  "limit": 10,
  "source_ids": [],
  "note_ids": [],
  "min_similarity": 0.7
}

search_type can be "vector" (requires embedding model) or "text" (keyword matching).

Ask with Streaming

POST /api/search/ask

Returns Server-Sent Events with AI-generated answers based on knowledge base content.

Ask Simple

POST /api/search/ask/simple

Non-streaming version that returns a complete response.

---

Podcasts

Generate Podcast

POST /api/podcasts/generate

Request Body:

{
  "notebook_id": "notebook:abc123",
  "episode_profile_id": "episode_profile:xyz",
  "speaker_profile_ids": ["speaker:a", "speaker:b"]
}

Returns a job_id for tracking generation progress.

Get Job Status

GET /api/podcasts/jobs/{job_id}

List Episodes

GET /api/podcasts/episodes

Get Episode

GET /api/podcasts/episodes/{episode_id}

Get Episode Audio

GET /api/podcasts/episodes/{episode_id}/audio

Streams the podcast audio file.

Retry Failed Episode

POST /api/podcasts/episodes/{episode_id}/retry

Delete Episode

DELETE /api/podcasts/episodes/{episode_id}

---

Transformations

List Transformations

GET /api/transformations

Create Transformation

POST /api/transformations

Request Body:

{
  "name": "summarize",
  "title": "Summarize Content",
  "description": "Generate a concise summary",
  "prompt": "Summarize the following text...",
  "apply_default": false
}

Execute Transformation

POST /api/transformations/execute

Request Body:

{
  "transformation_id": "transformation:abc",
  "input_text": "Text to transform...",
  "model_id": "model:xyz"
}

Get Default Prompt

GET /api/transformations/default-prompt

Update Default Prompt

PUT /api/transformations/default-prompt

Get Transformation

GET /api/transformations/{transformation_id}

Update Transformation

PUT /api/transformations/{transformation_id}

Delete Transformation

DELETE /api/transformations/{transformation_id}

---

Models

List Models

GET /api/models

Query Parameters:

Create Model

POST /api/models

Delete Model

DELETE /api/models/{model_id}

Test Model

POST /api/models/{model_id}/test

Get Default Models

GET /api/models/defaults

Returns default model assignments for seven service slots: chat, transformation, embedding, speech-to-text, text-to-speech, podcast, and summary.

Update Default Models

PUT /api/models/defaults

Get Providers

GET /api/models/providers

Discover Models

GET /api/models/discover/{provider}

Sync Models (Single Provider)

POST /api/models/sync/{provider}

Sync All Models

POST /api/models/sync

Auto-Assign Defaults

POST /api/models/auto-assign

Automatically populate empty default model slots using provider priority rankings.

Get Model Count

GET /api/models/count/{provider}

Get Models by Provider

GET /api/models/by-provider/{provider}

---

Credentials

Get Status

GET /api/credentials/status

Get Environment Status

GET /api/credentials/env-status

List Credentials

GET /api/credentials

Query Parameters:

List by Provider

GET /api/credentials/by-provider/{provider}

Create Credential

POST /api/credentials

Request Body:

{
  "provider": "openai",
  "name": "My OpenAI Key",
  "api_key": "sk-...",
  "base_url": null
}

Get Credential

GET /api/credentials/{credential_id}

Note: API key values are never returned.

Update Credential

PUT /api/credentials/{credential_id}

Delete Credential

DELETE /api/credentials/{credential_id}

Test Credential

POST /api/credentials/{credential_id}/test

Discover Models via Credential

POST /api/credentials/{credential_id}/discover

Register Models via Credential

POST /api/credentials/{credential_id}/register-models

---

Error Responses

The API returns standard HTTP status codes with JSON error bodies:

Error Response Format:

{
  "detail": "Description of the error"
}

Open Notebook Architecture

System Overview

Open Notebook is built as a modern Python web application with a clear separation between frontend and backend, using Docker for deployment.

┌─────────────────────────────────────────────────────┐
│                   Docker Compose                    │
│                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐  │
│  │   Next.js    │  │   FastAPI    │  │ SurrealDB │  │
│  │   Frontend   │──│   Backend    │──│           │  │
│  │  (port 8502) │  │  (port 5055) │  │ (port 8K) │  │
│  └──────────────┘  └──────────────┘  └───────────┘  │
│                          │                          │
│                    ┌─────┴─────┐                    │
│                    │ LangChain │                    │
│                    │ Esperanto │                    │
│                    └─────┬─────┘                    │
│                          │                          │
│              ┌───────────┼───────────┐              │
│              │           │           │              │
│          ┌───┴───┐   ┌───┴───┐   ┌───┴───┐          │
│          │OpenAI │   │Claude │   │Ollama │  ...     │
│          └───────┘   └───────┘   └───────┘          │
└─────────────────────────────────────────────────────┘

Core Components

FastAPI Backend

The REST API is built with FastAPI and organized into routers:

• 20 route modules covering notebooks, sources, notes, chat, search, podcasts, transformations, models, credentials, embeddings, settings, and more
• Async/await throughout for non-blocking I/O
• Pydantic models for request/response validation
• Custom exception handlers mapping domain errors to HTTP status codes
• CORS middleware for cross-origin access
• Optional password authentication middleware

SurrealDB

SurrealDB serves as the primary data store, providing both document and relational capabilities:

• Document storage for notebooks, sources, notes, transformations, and models
• Relational references for notebook-source associations
• Full-text search across indexed content
• RocksDB backend for persistent storage on disk
• Schema migrations run automatically on application startup

LangChain Integration

AI features are powered by LangChain with the Esperanto multi-provider library:

• LangGraph manages conversational state for chat sessions
• Embedding models power vector search across content
• LLM chains drive transformations, note generation, and podcast scripting
• Prompt templates stored in the prompts/ directory

Esperanto Multi-Provider Library

Esperanto provides a unified interface to 16+ AI providers:

• Abstracts provider-specific API differences
• Supports LLM, embedding, speech-to-text, and text-to-speech capabilities
• Handles credential management and model discovery
• Enables runtime provider switching without code changes

Next.js Frontend

The user interface is a React application built with Next.js:

• Responsive design for desktop and tablet use
• Real-time updates for chat and processing status
• File upload with progress tracking
• Audio player for podcast episodes

Data Flow

Source Ingestion

Upload/URL → Source Record Created → Processing Queue
                                         │
                              ┌──────────┼──────────┐
                              ▼          ▼          ▼
                          Text       Embedding   Metadata
                        Extraction   Generation  Extraction
                              │          │          │
                              └──────────┼──────────┘
                                         ▼
                                  Source Updated
                                  (searchable)

Chat Execution

User Message → Build Context (sources + notes)
                    │
                    ▼
              LangGraph State Machine
                    │
                    ├─ Retrieve relevant context
                    ├─ Format prompt with citations
                    └─ Stream LLM response
                         │
                         ▼
                   Response with
                   source citations

Podcast Generation

Notebook Content → Episode Profile → Script Generation (LLM)
                                          │
                                          ▼
                                    Speaker Assignment
                                          │
                                          ▼
                                    Text-to-Speech
                                    (per segment)
                                          │
                                          ▼
                                    Audio Assembly
                                          │
                                          ▼
                                    Episode Record
                                    + Audio File

Key Design Decisions

1. Multi-provider by default: Not locked to any single AI provider, enabling cost optimization and capability matching 2. Async processing: Long-running operations (source ingestion, podcast generation) run asynchronously with status polling 3. Self-hosted data: All data stays on the user's infrastructure with encrypted credential storage 4. REST-first API: Every UI action is backed by an API endpoint for automation 5. Docker-native: Designed for containerized deployment with persistent volumes

File Structure

open-notebook/
├── api/               # FastAPI REST API
│   ├── main.py        # App setup, middleware, routers
│   ├── routers/       # Route handlers (20 modules)
│   ├── models.py      # Pydantic request/response models
│   └── auth.py        # Authentication middleware
├── open_notebook/     # Core library
│   ├── ai/            # AI integration (LangChain, Esperanto)
│   ├── database/      # SurrealDB operations
│   ├── domain/        # Domain models and business logic
│   ├── graphs/        # LangGraph chat and processing graphs
│   ├── podcasts/      # Podcast generation pipeline
│   └── utils/         # Shared utilities
├── frontend/          # Next.js React application
├── prompts/           # AI prompt templates
├── tests/             # Test suite
└── docker-compose.yml # Deployment configuration

Open Notebook Configuration Guide

Docker Deployment

Open Notebook is deployed as a Docker Compose stack with two main services: the application server and SurrealDB.

Minimal docker-compose.yml

version: "3.8"

services:
  surrealdb:
    image: surrealdb/surrealdb:latest
    command: start --user root --pass root rocksdb://data/database.db
    volumes:
      - surrealdb_data:/data
    ports:
      - "8000:8000"

  open-notebook:
    image: ghcr.io/lfnovo/open-notebook:latest
    depends_on:
      - surrealdb
    environment:
      - OPEN_NOTEBOOK_ENCRYPTION_KEY=${OPEN_NOTEBOOK_ENCRYPTION_KEY}
      - SURREAL_URL=ws://surrealdb:8000/rpc
      - SURREAL_NAMESPACE=open_notebook
      - SURREAL_DATABASE=open_notebook
    ports:
      - "8502:8502"   # Frontend UI
      - "5055:5055"   # REST API
    volumes:
      - on_uploads:/app/uploads

volumes:
  surrealdb_data:
  on_uploads:

Starting the Stack

# Set the encryption key (required)
export OPEN_NOTEBOOK_ENCRYPTION_KEY="your-secure-random-key"

# Start services
docker-compose up -d

# View logs
docker-compose logs -f open-notebook

# Stop services
docker-compose down

# Stop and remove data
docker-compose down -v

Environment Variables

Required

Database

Application

AI Provider Keys (Legacy)

API keys can also be set via environment variables for legacy compatibility. The preferred method is using the credentials API or UI.

AI Provider Configuration

Via UI

1. Go to Settings > API Keys 2. Click Add Credential 3. Select provider, enter API key and optional base URL 4. Click Test Connection to verify 5. Click Discover Models to find available models 6. Select models to register

Via API

import requests

BASE_URL = "http://localhost:5055/api"

# 1. Create credential
cred = requests.post(f"{BASE_URL}/credentials", json={
    "provider": "anthropic",
    "name": "Anthropic Production",
    "api_key": "sk-ant-..."
}).json()

# 2. Test connection
test = requests.post(f"{BASE_URL}/credentials/{cred['id']}/test").json()
assert test["success"]

# 3. Discover and register models
discovered = requests.post(
    f"{BASE_URL}/credentials/{cred['id']}/discover"
).json()

requests.post(
    f"{BASE_URL}/credentials/{cred['id']}/register-models",
    json={"model_ids": [m["id"] for m in discovered["models"]]}
)

# 4. Auto-assign defaults
requests.post(f"{BASE_URL}/models/auto-assign")

Using Ollama (Free Local Inference)

For free AI inference without API costs, use Ollama:

# docker-compose-ollama.yml addition
services:
  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"

Then configure Ollama as a provider with base URL http://ollama:11434.

Security Configuration

Password Protection

Set OPEN_NOTEBOOK_PASSWORD to require authentication:

export OPEN_NOTEBOOK_PASSWORD="your-ui-password"

Reverse Proxy (Nginx Example)

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

    ssl_certificate /etc/ssl/certs/cert.pem;
    ssl_certificate_key /etc/ssl/private/key.pem;

    location / {
        proxy_pass http://localhost:8502;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
    }

    location /api/ {
        proxy_pass http://localhost:5055/api/;
        proxy_set_header Host $host;
    }
}

Backup and Restore

Backup SurrealDB Data

# Export database
docker exec surrealdb surreal export \
  --conn ws://localhost:8000 \
  --user root --pass root \
  --ns open_notebook --db open_notebook \
  /tmp/backup.surql

# Copy backup from container
docker cp surrealdb:/tmp/backup.surql ./backup.surql

Backup Uploaded Files

# Copy upload volume contents
docker cp open-notebook:/app/uploads ./uploads_backup/

Restore

# Import database backup
docker cp ./backup.surql surrealdb:/tmp/backup.surql
docker exec surrealdb surreal import \
  --conn ws://localhost:8000 \
  --user root --pass root \
  --ns open_notebook --db open_notebook \
  /tmp/backup.surql

Open Notebook Examples

Complete Research Workflow

This example demonstrates a full research workflow: creating a notebook, adding sources, generating notes, chatting with the AI, and searching across materials.

import requests
import time

BASE_URL = "http://localhost:5055/api"


def complete_research_workflow():
    """End-to-end research workflow with Open Notebook."""

    # 1. Create a research notebook
    notebook = requests.post(f"{BASE_URL}/notebooks", json={
        "name": "Drug Resistance in Cancer",
        "description": "Review of mechanisms of drug resistance in solid tumors"
    }).json()
    notebook_id = notebook["id"]
    print(f"Created notebook: {notebook_id}")

    # 2. Add sources from URLs
    urls = [
        "https://www.nature.com/articles/s41568-020-0281-y",
        "https://www.cell.com/cancer-cell/fulltext/S1535-6108(20)30211-8",
    ]

    source_ids = []
    for url in urls:
        source = requests.post(f"{BASE_URL}/sources", data={
            "url": url,
            "notebook_id": notebook_id,
            "process_async": "true"
        }).json()
        source_ids.append(source["id"])
        print(f"Added source: {source['id']}")

    # 3. Wait for processing to complete
    for source_id in source_ids:
        while True:
            status = requests.get(
                f"{BASE_URL}/sources/{source_id}/status"
            ).json()
            if status.get("status") in ("completed", "failed"):
                break
            time.sleep(5)
        print(f"Source {source_id}: {status['status']}")

    # 4. Create a chat session and ask questions
    session = requests.post(f"{BASE_URL}/chat/sessions", json={
        "notebook_id": notebook_id,
        "title": "Resistance Mechanisms"
    }).json()

    answer = requests.post(f"{BASE_URL}/chat/execute", json={
        "session_id": session["id"],
        "message": "What are the primary mechanisms of drug resistance in solid tumors?",
        "context": {"include_sources": True, "include_notes": True}
    }).json()
    print(f"AI response: {answer}")

    # 5. Search across materials
    results = requests.post(f"{BASE_URL}/search", json={
        "query": "efflux pump resistance mechanism",
        "search_type": "vector",
        "limit": 5
    }).json()
    print(f"Found {results['total']} search results")

    # 6. Create a human note summarizing findings
    note = requests.post(f"{BASE_URL}/notes", json={
        "title": "Summary of Resistance Mechanisms",
        "content": "Key findings from the literature...",
        "note_type": "human",
        "notebook_id": notebook_id
    }).json()
    print(f"Created note: {note['id']}")


if __name__ == "__main__":
    complete_research_workflow()

File Upload Example

import requests

BASE_URL = "http://localhost:5055/api"


def upload_research_papers(notebook_id, file_paths):
    """Upload multiple research papers to a notebook."""
    for path in file_paths:
        with open(path, "rb") as f:
            response = requests.post(
                f"{BASE_URL}/sources",
                data={
                    "notebook_id": notebook_id,
                    "process_async": "true",
                },
                files={"file": (path.split("/")[-1], f)},
            )
        if response.status_code == 200:
            print(f"Uploaded: {path}")
        else:
            print(f"Failed: {path} - {response.text}")


# Usage
upload_research_papers("notebook:abc123", [
    "papers/study_1.pdf",
    "papers/study_2.pdf",
    "papers/supplementary.docx",
])

Podcast Generation Example

import requests
import time

BASE_URL = "http://localhost:5055/api"


def generate_research_podcast(notebook_id):
    """Generate a podcast episode from notebook contents."""

    # Get available episode and speaker profiles
    # (these must be configured in the UI or via API first)

    # Submit podcast generation job
    job = requests.post(f"{BASE_URL}/podcasts/generate", json={
        "notebook_id": notebook_id,
        "episode_profile_id": "episode_profile:default",
        "speaker_profile_ids": [
            "speaker_profile:host",
            "speaker_profile:expert"
        ]
    }).json()
    job_id = job["job_id"]
    print(f"Podcast generation started: {job_id}")

    # Poll for completion
    while True:
        status = requests.get(f"{BASE_URL}/podcasts/jobs/{job_id}").json()
        print(f"Status: {status.get('status', 'processing')}")
        if status.get("status") in ("completed", "failed"):
            break
        time.sleep(10)

    if status["status"] == "completed":
        # Download the audio
        episode_id = status["episode_id"]
        audio = requests.get(
            f"{BASE_URL}/podcasts/episodes/{episode_id}/audio"
        )
        with open("research_podcast.mp3", "wb") as f:
            f.write(audio.content)
        print("Podcast saved to research_podcast.mp3")


if __name__ == "__main__":
    generate_research_podcast("notebook:abc123")

Custom Transformation Pipeline

import requests

BASE_URL = "http://localhost:5055/api"


def create_and_run_transformations():
    """Create custom transformations and apply them to content."""

    # Create a methodology extraction transformation
    transform = requests.post(f"{BASE_URL}/transformations", json={
        "name": "extract_methods",
        "title": "Extract Methods",
        "description": "Extract and structure methodology from papers",
        "prompt": (
            "Extract the methodology section from this text. "
            "Organize into: Study Design, Sample Size, Statistical Methods, "
            "and Key Variables. Format as structured markdown."
        ),
        "apply_default": False,
    }).json()

    # Get models to find a suitable one
    models = requests.get(f"{BASE_URL}/models", params={
        "model_type": "llm"
    }).json()
    model_id = models[0]["id"]

    # Execute the transformation
    result = requests.post(f"{BASE_URL}/transformations/execute", json={
        "transformation_id": transform["id"],
        "input_text": "We conducted a randomized controlled trial with...",
        "model_id": model_id,
    }).json()
    print(f"Extracted methods:\n{result['output']}")


if __name__ == "__main__":
    create_and_run_transformations()

Semantic Search with Filtering

import requests

BASE_URL = "http://localhost:5055/api"


def advanced_search(notebook_id, query):
    """Perform filtered semantic search and get AI answers."""

    # Get sources from a specific notebook
    sources = requests.get(f"{BASE_URL}/sources", params={
        "notebook_id": notebook_id
    }).json()
    source_ids = [s["id"] for s in sources]

    # Vector search restricted to notebook sources
    results = requests.post(f"{BASE_URL}/search", json={
        "query": query,
        "search_type": "vector",
        "limit": 10,
        "source_ids": source_ids,
        "min_similarity": 0.75,
    }).json()

    print(f"Found {results['total']} results:")
    for result in results["results"]:
        print(f"  - {result.get('title', 'Untitled')} "
              f"(similarity: {result.get('similarity', 'N/A')})")

    # Get an AI-powered answer
    answer = requests.post(f"{BASE_URL}/search/ask/simple", json={
        "query": query,
    }).json()
    print(f"\nAI Answer: {answer['response']}")


if __name__ == "__main__":
    advanced_search("notebook:abc123", "CRISPR gene editing efficiency")

Model Management

import requests

BASE_URL = "http://localhost:5055/api"


def setup_ai_models():
    """Configure AI models for Open Notebook."""

    # Check available providers
    providers = requests.get(f"{BASE_URL}/models/providers").json()
    print(f"Available providers: {providers}")

    # Discover models from a provider
    discovered = requests.get(
        f"{BASE_URL}/models/discover/openai"
    ).json()
    print(f"Discovered {len(discovered)} OpenAI models")

    # Sync models to make them available
    requests.post(f"{BASE_URL}/models/sync/openai")

    # Auto-assign default models
    requests.post(f"{BASE_URL}/models/auto-assign")

    # Check current defaults
    defaults = requests.get(f"{BASE_URL}/models/defaults").json()
    print(f"Default models: {defaults}")


if __name__ == "__main__":
    setup_ai_models()