terryum/terryum-ai

On the Manifold — Terry's External Brain

한국어 | English

A personal homepage and AI-operated knowledge base for robotics & AI research.

Live: www.terryum.ai

What This Is

On the Manifold is a bilingual (Korean/English) research blog, knowledge graph, and personal homepage. Inspired by Andrej Karpathy's approach to external-brain knowledge management, the entire content pipeline is operated by Claude Code — papers are summarized, indexed, connected, and published through natural language commands.

The site hosts 40+ research paper summaries, tech essays, notes, and an interactive paper relationship graph. The project uses a multi-workspace setup:

Architecture

┌───────────────────────────────────────────┐
│          Claude Code (AI Agent)           │
│       /post  /project  /post-share        │
└──────┬──────────────┬──────────────┬──────┘
       v              v              v
  posts/ (MDX)    Supabase     Obsidian Vault
  index.json      (Graph DB)   (Local Knowledge)
       |              |              |
       v              v              v
  ┌──────────┐  ┌──────────┐   ┌────────────┐
  │CF Worker │  │  Paper   │   │ Wikilinks  │
  │ (OpenNxt)│  │  Map UI  │   │ + Dataview │
  └──────────┘  └──────────┘   └────────────┘

Skills (Claude Code Commands)

Skills are split across two workspaces:

This repo (terryum-ai) — site development + content pipeline:

terry-obsidian — Obsidian vault management + content publishing:

For Those Who Want to Build Something Similar

This is a personal project, not a plug-and-play template. However, since the repository is public and MIT-licensed, you're welcome to study the structure and adapt it. Below is a guide covering what you get by cloning, what you need to set up yourself, and how the pieces connect.

What You Get by Cloning

• Full Next.js 15 site source code (App Router, i18n routing, MDX rendering)
• Content pipeline: posts/{papers,essays,notes}/ folder structure
• Paper relationship graph UI (React Flow + Supabase)
• Admin dashboard (stats, graph editor — behind password)
• Group-based access control for private content (/co/[group])
• Claude Code harness (.claude/agents/, .claude/skills/) — site dev skills; Obsidian skills live in terry-obsidian
• Obsidian sync script (scripts/sync-obsidian.mjs)
• Social media publishing script (scripts/publish-social.py)
• All published post content (MDX + images)

What You Need to Set Up Yourself

Step-by-Step Setup

1. Clone and Install

git clone https://github.com/terryum/terryum-ai.git
cd terryum-ai
npm install
cp .env.example .env.local

2. Environment Variables (.env.local)

At minimum, you need:

# Site
NEXT_PUBLIC_SITE_URL=http://localhost:3040

# Identity / Session (HMAC cookie key + admin email)
SESSION_SECRET=generate-a-64-char-hex-string
[email protected]

# Google OAuth (register redirect URI at Google Cloud Console)
GOOGLE_OAUTH_CLIENT_ID=xxxxx.apps.googleusercontent.com
GOOGLE_OAUTH_CLIENT_SECRET=GOCSPX-xxxxx

# Supabase (optional — site works without it, but Paper Map won't)
NEXT_PUBLIC_SUPABASE_URL=https://xxxxx.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=eyJ...
SUPABASE_SERVICE_ROLE_KEY=eyJ...

For the full list, see .env.example.

3. Supabase (Paper Graph Database)

The paper relationship graph requires three tables. Apply the migration:

# Option A: Supabase CLI
supabase db push

# Option B: Run SQL manually in Supabase Dashboard
# Copy contents of supabase/migrations/001_initial_schema.sql

Tables created:

• papers — paper metadata (slug, title, domain, concepts)
• graph_edges — relationships between papers (builds_on, extends, etc.)
• node_layouts — React Flow canvas positions

If you skip this step, the site still works — the Paper Map page will show a fallback message.

Additionally, 002_acl_schema.sql creates tables for legacy group-based access control (deprecated — access control now uses inline visibility fields in meta.json instead of Supabase).

4. Run Locally

npm run dev  # Starts on localhost:3040

5. Deploy to Cloudflare Workers

npm run build:cf          # OpenNext build for Workers
npx opennextjs-cloudflare deploy   # Deploy via wrangler

Runtime env vars go in wrangler.jsonc (vars for public, secrets via wrangler secret put for sensitive). See .env.production for the set of NEXT_PUBLIC_* vars that Next.js inlines into the bundle at build time.

Access Control (Inline Visibility)

The site supports per-post visibility scoping for sharing private content with specific collaborator groups.

Public posts              Group-scoped posts
visibility: "public"      visibility: "group", allowed_groups: ["snu"]
Visible to everyone       Visible after /co/snu login
Same posts/ directory     Same posts/ directory

How it works:

1. Each group has a password set via environment variable:

   CO_SNU_PASSWORD=your-password
   CO_KAIST_PASSWORD=another-password
   

2. Group-scoped posts are stored in Git alongside public posts, with visibility and allowed_groups fields in meta.json

3. Collaborators visit /co/snu, enter the password, then get redirected to the main site where group-scoped posts become visible

4. Unauthenticated users accessing a group post URL are redirected to the login page

5. Admin session grants access to all groups

Key features:

• HMAC-SHA256 signed session tokens (24-hour validity)
• Rate limiting (5 attempts per 15 minutes)
• Group posts excluded from sitemap and marked noindex
• Groups are isolated — co-snu session cannot see co-kaist content

Obsidian Integration Guide

This is the part that requires the most manual setup, since the Obsidian vault lives on your local machine and is not included in the repository.

What the Obsidian Integration Does

Homepage (posts/)  ──sync-obsidian.mjs──►  Obsidian Vault
                                            ├── Public/Papers/   ← research summaries
                                            ├── Public/Essays/   ← essays
                                            ├── Public/Notes/    ← short notes + ChatGPT summaries
                                            ├── Private/Drafts/  ← unpublished drafts
                                            └── Ops/Meta/        ← taxonomy, concept index

• Published posts are synced as Obsidian notes with wikilinks and frontmatter
• Manual notes created in Obsidian get negative IDs (#-1, #-2, ...) and can be referenced in Claude Code commands
• The sync is one-directional (homepage → Obsidian) for published content, but Obsidian notes can be pulled back via /write

Setting Up Obsidian

1. Install Obsidian: Download from obsidian.md

2. Create a vault: Create or open a vault at your preferred location (e.g., ~/Documents/Obsidian Vault)

3. Initialize vault structure:

   # Creates the required folder hierarchy
   node scripts/sync-obsidian.mjs --init --vault="/path/to/your/vault"
   

   This creates:

   Your Vault/
   ├── Public/
   │   ├── Papers/
   │   ├── Essays/
   │   └── Notes/
   ├── Private/
   │   ├── Drafts/
   │   ├── Notes/
   │   └── Tasks/
   └── Ops/
       ├── Meta/
       └── Templates/
   

4. Sync posts to Obsidian:

   node scripts/sync-obsidian.mjs --vault="/path/to/your/vault"
   

5. Recommended Obsidian plugins:

   • Dataview — query and filter notes by frontmatter fields
   • Graph View (built-in) — visualize wikilink connections
   • Templates — use templates in Ops/Templates/

How Posts Become Obsidian Notes

Each synced note gets frontmatter like:

---
doc_id: 5
slug: 2505-forcevla-force-aware-moe
content_type: papers
domain: robotics
tags: [VLA, force-control, MoE]
sync_hash: a1b2c3d4
synced_at: 2026-04-07T12:00:00Z
---

And the body includes a ## Relations section with wikilinks to related papers — these are preserved even when re-syncing.

Content Structure

Posts follow a consistent directory pattern:

posts/
├── index.json                           # Master index of all posts
├── papers/
│   └── 2505-forcevla-force-aware-moe/
│       ├── meta.json                    # Full metadata
│       ├── ko.mdx                       # Korean content
│       ├── en.mdx                       # English content
│       └── cover.webp                   # Cover image
├── essays/
│   └── 260310-brain-augmentation/
│       └── [same structure]
└── notes/
    └── 260419-vercel-quiet-bill/
        └── [same structure]

• content_type = folder name = URL tab slug
• Every post has both ko.mdx and en.mdx (bilingual)
• index.json is the source of truth for post ordering and metadata
• meta.json per post is optional (frontmatter in MDX is the fallback)

ID System

• Public posts: positive IDs (#1, #2, ...) — visible on the website
• Private drafts: negative IDs (#-1, #-2, ...) — Obsidian only, never published
• Any document is referenceable by #number in Claude Code commands

Adapting for Your Own Use

If you want to build your own version rather than forking:

1. Start with the site: The Next.js app works standalone. Remove my posts, update src/lib/site-config.ts with your info
2. Add your content: Create posts in posts/{type}/{slug}/ with ko.mdx, en.mdx, cover.webp
3. Set up Supabase (optional): Only needed for the Paper Map feature
4. Set up Obsidian (optional): Only needed if you want local knowledge graph management
5. Configure Claude Code (optional): The .claude/ harness is designed for my workflow — modify or remove as needed

License

MIT