2BToRePensieve

Status (2026-03-24): Active development. See Release Notes for the latest changes.

A cloud-hosted personal knowledge graph you can talk to from any AI assistant.

Second Brain + Total Recall + Pensieve — capture everything, forget nothing, recall instantly.

2BToRePensieve builds a persistent knowledge graph from your notes, conversations, emails, YouTube videos, and Notion pages. It extracts entities, relationships, and observations automatically, then makes everything searchable via semantic search with LLM reranking — accessible from ChatGPT, Claude, Cursor, or any MCP-compatible client.

How It Works

┌─────────────────────────────────────────────────────────────────┐
│                        INPUT CHANNELS                           │
│  ChatGPT  Claude  Notion  YouTube  Telegram  Email  Local Files │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                    ┌──────▼──────┐
                    │   Ingest    │  LLM extraction + embedding
                    │  Pipeline   │  (2-3 LLM calls per chunk)
                    └──────┬──────┘
                           │
              ┌────────────▼────────────────┐
              │      Supabase + pgvector    │
              │  ┌────────┐  ┌───────────┐  │
              │  │Entities│──│ Relations │  │
              │  └────┬───┘  └───────────┘  │
              │  ┌────▼──────┐ ┌─────────┐  │
              │  │Observations│ │  Tasks  │  │
              │  └────────────┘ └─────────┘  │
              └────────────┬────────────────┘
                           │
                    ┌──────▼──────┐
                    │ MCP Server  │  12 tools, LLM reranking
                    └──────┬──────┘
                           │
              ┌────────────▼────────────────┐
              │       ACCESS POINTS         │
              │  ChatGPT  Claude  Cursor    │
              │  Telegram Bot  Any MCP app  │
              └─────────────────────────────┘

Related MCP server: Semantic Notes Vault MCP

Features

• Knowledge Graph — Entities, relations, and observations extracted automatically from any text

• Semantic Search — pgvector cosine similarity + LLM reranking for high-relevance results

• 12 MCP Tools — search, add thoughts, manage tasks, explore entities, view stats

• GTD Task System — inbox/next/waiting/someday/done with priorities and projects

• 7 Input Channels — ChatGPT, Claude, Notion, YouTube, Telegram, Email, local files

• 5-Layer Dedup — Content hash, semantic similarity, entity name+type, relation edges, observation hash

• Daily Sync — GitHub Actions for Notion, local Task Scheduler for YouTube (cloud IPs blocked by YouTube)

• Batched Pipeline — 2-3 LLM calls + 2 embedding calls per chunk (not per entity)

Quick Start

1. Set up Supabase

Create a Supabase project (free tier works). Run the migrations in order:

# In Supabase SQL Editor, run each file in supabase/migrations/:
# 001_create_knowledge_graph.sql
# 002_add_stats_functions.sql
# 003_add_dedup_constraints.sql
# 004_add_tasks_and_sync.sql
# 005_add_search_similar_entities.sql

2. Set up OpenRouter

Create an OpenRouter account and add credits. Get your API key.

Default models (configurable):

• Chat/Extraction: openai/gpt-4o-mini (~$0.15/1M input tokens)

• Embeddings: openai/text-embedding-3-small (~$0.02/1M tokens)

3. Deploy Edge Functions

# Install Supabase CLI
npm i -g supabase

# Link your project
supabase link --project-ref your-project-ref

# Set secrets
supabase secrets set \
  OPENROUTER_API_KEY=sk-or-v1-your-key \
  OPEN_BRAIN_ACCESS_KEY=$(python -c "import secrets; print(secrets.token_hex(32))")

# Deploy all functions
supabase functions deploy ingest --no-verify-jwt
supabase functions deploy mcp-server --no-verify-jwt
supabase functions deploy telegram-capture --no-verify-jwt
supabase functions deploy email-capture --no-verify-jwt
supabase functions deploy slack-capture --no-verify-jwt

4. Connect Your AI Client

Claude Code / Cursor

Add to your MCP config (.claude/mcp.json or .cursor/mcp.json):

{
  "mcpServers": {
    "open-brain": {
      "type": "url",
      "url": "https://your-project.supabase.co/functions/v1/mcp-server",
      "headers": {
        "Authorization": "Bearer YOUR_ACCESS_KEY"
      }
    }
  }
}

ChatGPT

Use a ChatGPT MCP connector plugin. Set the server URL to:

https://your-project.supabase.co/functions/v1/mcp-server?key=YOUR_ACCESS_KEY

5. Install Python Dependencies

pip install supabase openai httpx python-dotenv yt-dlp youtube-transcript-api PyMuPDF

6. Configure Environment

cp .env.example .env
# Edit .env with your credentials

Documentation

• Usage Guide — How to use the system day to day: searching, adding thoughts, managing tasks, importing content

• Channel Setup — How to configure each input channel (Telegram, Email, Notion, YouTube, etc.)

• Supabase Setup — Database and Edge Function setup

• Architecture — Technical design and data flow

MCP Tools

Connectors

Project Structure

2BToRePensieve/
├── open_brain/                    # Python package
│   ├── config.py                  # Environment-based configuration
│   ├── db.py                      # Supabase client + all DB operations
│   ├── embeddings.py              # Cloud (OpenRouter) + local (LM Studio) embeddings
│   ├── ingest.py                  # Core ingestion pipeline
│   ├── chunking.py                # Text chunking with sentence-boundary splitting
│   ├── extraction/
│   │   ├── extractor.py           # LLM knowledge extraction
│   │   ├── entity_resolver.py     # Batch entity resolution + merge confirmation
│   │   └── prompts.py             # LLM prompt templates
│   ├── connectors/
│   │   ├── chatgpt_conversations.py
│   │   ├── claude_conversations.py
│   │   ├── notion_database.py
│   │   ├── youtube.py
│   │   ├── local_bulk.py
│   │   ├── local_sync.py
│   │   ├── whatsapp_export.py
│   │   └── pdf_ingest.py
│   └── backup/
│       └── backup.py              # pg_dump + JSONL export
├── supabase/
│   ├── config.toml
│   ├── migrations/                # Run these in order
│   │   ├── 001_create_knowledge_graph.sql
│   │   ├── 002_add_stats_functions.sql
│   │   ├── 003_add_dedup_constraints.sql
│   │   ├── 004_add_tasks_and_sync.sql
│   │   └── 005_add_search_similar_entities.sql
│   └── functions/
│       ├── ingest/                # Universal ingestion Edge Function
│       ├── mcp-server/            # MCP protocol server (12 tools)
│       ├── telegram-capture/      # Telegram bot webhook
│       ├── email-capture/         # Resend inbound email webhook
│       └── slack-capture/         # Slack event webhook
├── scripts/
│   └── sync-youtube.ps1           # Local YouTube sync (Task Scheduler)
└── .github/
    └── workflows/
        └── daily-sync.yml         # Cron: Notion daily sync

Database Schema

6 tables, 3 RPC functions, pgvector HNSW indexes:

• sources — Raw ingested content with content_hash dedup

• entities — People, concepts, projects, tools, decisions, events (with embeddings)

• relations — Directed edges between entities

• observations — Facts, insights, decisions linked to entities (with embeddings)

• tasks — GTD task system with embeddings for semantic search

• sync_state — Cursor tracking for incremental connector sync

RPC functions:

• search_knowledge — Union search across entities + observations + tasks

• get_entity_context — Full entity context with relations, observations, tasks

• search_similar_entities — Fast entity-only similarity search for ingestion

• get_top_connected_entities — Most connected entities by relation count

Ingestion Pipeline

Each chunk goes through this optimized pipeline:

1. Dedup check — SHA-256 content hash (DB only)

2. Store source — Insert raw content (DB only)

3. Extract knowledge — 1 LLM call extracts entities, relations, observations

4. Batch embed entities — 1 API call for all entity texts

5. Search candidates — DB calls to search_similar_entities RPC

6. Batch merge confirmation — 0-1 LLM call for all merge candidates

7. Upsert entities — Create new or merge into existing (DB only)

8. Store relations — Dedup by (source, target, type) edge (DB only)

9. Batch embed observations — 1 API call for all observation texts

10. Dedup + store observations — Hash + semantic dedup (DB only)

Total: 2-3 LLM calls + 2 embedding calls per chunk.

Cost Estimate

With gpt-4o-mini + text-embedding-3-small via OpenRouter:

Typical monthly cost: $5-15 for moderate personal use.

Daily Sync

Notion (GitHub Actions)

The included workflow runs daily at 6 AM UTC:

• Syncs pages from a Notion database, 50 pages per run

• Two-phase sync: re-ingests modified pages, then backfills un-ingested pages

• Safe limit for the 6-hour GitHub Actions timeout: ~300 pages per run

Set these GitHub Actions secrets:

• SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY

• OPENROUTER_API_KEY

• NOTION_API_TOKEN, NOTION_DATABASE_ID

• TELEGRAM_BOT_TOKEN, TELEGRAM_NOTIFY_CHAT_ID (optional, for notifications)

YouTube (Local Task Scheduler)

Why not GitHub Actions? YouTube blocks transcript requests from cloud provider IPs (AWS, GCP, Azure). All GitHub Actions runners use cloud IPs, so every transcript fetch fails with RequestBlocked. See YouTube IP Blocking for details and alternatives.

YouTube sync runs locally via Windows Task Scheduler using your home IP:

# Register the scheduled task (run once)
$repoRoot = "C:\path	oBToRePensieve"
$scriptPath = Join-Path $repoRoot "scripts\sync-youtube.ps1"

$action = New-ScheduledTaskAction `
    -Execute "powershell.exe" `
    -Argument "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`"" `
    -WorkingDirectory $repoRoot

$trigger = New-ScheduledTaskTrigger -Daily -At "6:00AM"

$settings = New-ScheduledTaskSettingsSet `
    -AllowStartIfOnBatteries `
    -DontStopIfGoingOnBatteries `
    -WakeToRun `
    -StartWhenAvailable `
    -ExecutionTimeLimit (New-TimeSpan -Hours 1)

Register-ScheduledTask `
    -TaskName "OpenBrain-YouTube-Sync" `
    -Description "Daily YouTube playlist sync for knowledge graph" `
    -Action $action `
    -Trigger $trigger `
    -Settings $settings

The -WakeToRun flag wakes the computer from sleep to run the sync, then it goes back to sleep.

Before running: Edit scripts/sync-youtube.ps1 and set your playlist URL.

Inspiration

Inspired by Nate B. Jones' Open Brain guide, which demonstrated the core idea: Supabase + OpenRouter + MCP to give every AI tool you use the same persistent memory via a single URL.

The problem is simple — your knowledge lives in too many places. Zotero, browser bookmarks, Notion, YouTube watch-later playlists, ChatGPT conversations, Claude chats, Slack threads, emails. None of them talk to each other, and none of them are accessible when you're working in a different tool.

2BToRePensieve takes the Open Brain concept and extends it from a Slack capture + 4 MCP tools into a full knowledge graph with:

• Entity extraction and resolution — not just storing text, but building a graph of people, concepts, projects, and their relationships

• 7 input channels instead of just Slack — ChatGPT, Claude, Notion, YouTube, Telegram, Email, local files

• 12 MCP tools — search, capture, entity exploration, task management, stats

• Batched pipeline — optimized from N LLM calls per entity down to 2-3 calls per chunk

• 5-layer dedup — content hash, semantic similarity, entity merge, relation dedup, observation dedup

• GTD task system — embedded in the knowledge graph for cross-referencing

• Daily automated sync — GitHub Actions cron for Notion and YouTube

The name combines Second Brain, Total Recall, and Pensieve (Harry Potter) — one ring to rule them all.

Extensions & Ideas

Ways to extend this that we haven't built yet:

YouTube IP Blocking

YouTube's transcript API blocks requests from cloud provider IPs. This affects any CI/CD runner (GitHub Actions, GitLab CI, CircleCI, etc.) because they all use cloud infrastructure.

Symptoms:

• RequestBlocked or IpBlocked exception from youtube-transcript-api

• Error: "YouTube is blocking requests from your IP"

• All transcript fetches fail, 0 videos ingested

Solutions (pick one):

This project uses the Local Task Scheduler approach via scripts/sync-youtube.ps1.

Known Issues

Issues identified during code review (2026-03-04). Fixes in progress.

Security

Code & Config

Documentation

V2.0 Roadmap

What's planned for the next major version:

• Multimodal ingestion — images (OCR + vision LLM descriptions), audio (Whisper transcription), screenshots, diagrams

• Agentic workflows — the knowledge graph reasons over itself: auto-link related observations, suggest connections, generate weekly digests

• Temporal awareness — "What did I know about X last month?" vs "What do I know now?" — versioned observations with time-travel queries

• Confidence scoring — track observation reliability: primary source vs hearsay vs LLM-generated, with confidence decay over time

• Graph RAG — multi-hop retrieval: "What do my colleagues think about the tools I'm considering for the project?" traverses person→opinion→tool→project

• Mobile app — native iOS/Android for quick capture with photo, voice, and location context

• Federated sync — merge knowledge graphs across devices/instances without a central server

• Plugin system — drop-in connector SDK so anyone can build new input channels

Release Notes

v0.3.4 (2026-03-24)

Telegram intent detection fix + search optimization

• Fixed intent classifier misrouting personal questions (calendar events, travel plans, meetings) to ambiguous fallback instead of search_knowledge. Questions like "When is my flight?" or "Where am I staying?" now correctly trigger a knowledge graph search.

• Updated classifier prompt rules: any question (who/what/when/where/why/how) now defaults to search_knowledge — the knowledge graph contains personal notes, calendar events, travel plans, and conversations, so personal questions should always search.

• Flipped ambiguity bias: "when in doubt between search_knowledge and ambiguous, prefer search_knowledge" (was: prefer ambiguous). Only greetings, single words, emojis, and prompt injection attempts trigger the fallback.

• Optimized searchBrain() with batch entity/source fetching — 2 queries instead of N+1 per search result.

• Added 7 new intent detection test cases covering personal/calendar/event questions.

v0.3.3 (2026-03-19)

YouTube backfill improvements

• Added --newest-first flag to YouTube connector — indexes most recent playlist additions first instead of oldest-first, so new content is available sooner during backfill.

• Bumped Task Scheduler daily limit from 10 to 15 videos/day.

v0.3.2 (2026-03-18)

Structured output schema enforcement + DB-layer type safety

• Replaced json_object response format with json_schema structured output. Entity and observation types are now enum-constrained at the token generation level — the LLM physically cannot produce an invalid type.

• Added defense-in-depth _safe_entity_type() in db.py with an extended alias map (30+ biomedical/science types like organ, bacteria, journal → valid types). Acts as a second safety net if schema enforcement is unavailable on the model.

• Improved upsert_entity duplicate key fallback with ilike + eq cascade for more robust entity resolution.

• Fixed Windows cp1252 encoding crash in retry_failed.py when source titles contain Greek characters or other non-ASCII.

• Result: all 450+ previously failed source extractions resolved (0 failures remaining).

v0.3.1 (2026-03-18)

Entity type expansion + extraction resilience

• Added 3 new entity types: technology, event, decision (total: 9). Common LLM-generated types outside this set are auto-mapped to the nearest valid type (e.g., platform -> tool, place -> concept).

• Fixed upsert_entity fallback lookup: the unique constraint is on lower(name) only, but the fallback was matching on name+type, causing crashes when the same entity was extracted with different types across chunks.

• Added retry_failed.py — standalone script to re-run extraction on sources with status='failed' without re-inserting or re-embedding. Sends Telegram notification on completion.

• Migration 008: expands the entity type check constraint and reclassifies existing entities.

v0.3.0 (2026-03-18)

Notion backfill sync fix

• The --sync flag previously only queried Notion for pages modified after last_edited_time, which meant un-ingested pages in the backlog were never picked up. Now fetches all pages and locally filters into two groups: (a) pages modified since last sync (re-ingest) and (b) pages never ingested (backfill). Prioritizes modified pages, then fills the backlog up to --limit.

YouTube sync moved to local execution

• YouTube blocks transcript requests from cloud provider IPs (all GitHub Actions runners). Moved YouTube sync to a local Windows Task Scheduler script (scripts/sync-youtube.ps1) that uses your home IP.

• Added --cookies flag to youtube.py for optional cookie-based authentication.

• Fixed UnicodeEncodeError crash on Windows when video titles contain emoji/unicode characters.

Other fixes

• N+1 query fix + HNSW search optimization (20x speedup)

• MCP server concurrency fix (per-request server instances)

• Defensive error handling on all edge function API calls

• Tiered PDF extraction (unpdf v1.4 + OpenAI vision fallback)

• Telegram notification for daily sync results

v0.2.0 (2026-03-05)

Initial public release with core knowledge graph, 7 input channels, 12 MCP tools, and daily sync via GitHub Actions.

License

MIT