KnowledgeFactory - Your AI-Powered 2nd Brain

🧠 What is KnowledgeFactory?

KnowledgeFactory is a complete AI-powered framework for managing the entire lifecycle of knowledge—from initial capture through to sharing with the world. It’s not just a tool, it’s a manufacturing system for knowledge that transforms raw information into refined, organized, and shareable insights.

Think of it as an assembly line for your thoughts:

Raw Information → Capture → Curate → Nurture → Develop → Evolve → Share → Refined Knowledge
      ↓              ↓        ↓         ↓         ↓         ↓        ↓
   YouTube        AI Tag   Connect   Refine    Update   Publish   Impact
   Articles      Organize  Related   Ideas    Links    World
   Ideas         Format    Notes     Structure Search   Access
   Code          Store     Graph     Polish    AI       Control

The Knowledge Lifecycle:

📥 Capture - Grab everything: videos, articles, repos, ideas, anywhere
🏷️ Curate - AI organizes, tags, and formats automatically
🌱 Nurture - Build connections between related ideas
🔨 Develop - Refine and structure your knowledge
🔄 Evolve - Update and maintain as understanding deepens
🌐 Share - Publish and distribute to the world

What makes it a “factory”?

Automated workflows: AI handles repetitive tasks
Quality control: Consistent formatting and organization
Scalable production: Process 10 or 10,000 notes with equal ease
Zero waste: Every piece of information is captured and utilized
Just-in-time delivery: Find what you need, when you need it

🎯 Why KnowledgeFactory?

The Problem: Broken Knowledge Workflow

Most people have a broken assembly line:

Traditional Approach (Manual Factory):

Capture → [BOTTLENECK] → Organize → [BOTTLENECK] → Find → [GIVE UP]
   ↓           ↓              ↓            ↓           ↓
YouTube    Manual tagging  Searching   Can't find  Never share
Links      No energy       Keywords    Lost        Abandoned
Ideas      Later™          No time     Forgotten   Wasted

Result: 1000+ inputs, 50 organized, 5 findable, 0 shared
        95% waste rate

Why traditional tools fail:

Manual bottlenecks - Every stage requires exhausting human effort
Hard to organize - Manual tagging and categorization feels impossible at scale
Impossible to find - Search fails without perfect keywords; semantic meaning is lost
Broken connections - Can’t link related knowledge across your entire collection
No quality control - Inconsistent organization makes everything harder to use
Broken conveyor belts - Ideas get stuck between stages, never fully processed
No distribution - Knowledge never reaches others because it’s not “ready” to share

The Solution: Automated Knowledge Factory

![[images/knowledgefactory-integrated-ui-terminal-plugin.png]]

KnowledgeFactory eliminates bottlenecks with AI-powered automation:

KnowledgeFactory Approach (Automated Factory):

Capture → Auto-Curate → Auto-Connect → Semantic Search → One-Click Share
   ↓           ↓             ↓               ↓                ↓
 /capture    AI tags     Related notes   Find anything    Published
 /idea       Format      Graph links     By meaning       Accessible
 /youtube    Store       Connections     Zero effort      Shared

Result: 1000+ inputs, 1000 organized, 1000 findable, 500+ shared
        0% waste rate, maximum value extraction

Core Principles:

✅ Automated Processing: AI handles 90% of organization work ✅ Continuous Flow: No bottlenecks between lifecycle stages ✅ Quality Assurance: Consistent formatting and tagging ✅ Smart Retrieval: Find anything by meaning, not just keywords ✅ Efficient Distribution: Share-ready output with one command

🚀 Infinite Expandability: Your Factory Grows With You

KnowledgeFactory is not a fixed system—it’s a modular platform that expands to meet your evolving needs.

Unlike traditional tools with locked-in features, KnowledgeFactory uses the Model Context Protocol (MCP) to add new capabilities on-demand. Think of MCP servers as “factory machines” you can install to process new types of input or create new types of output.

🎯 The MCP Advantage

300+ MCP Servers Available in the Docker MCP Toolkit Catalog

Zero coding required - Install servers with one click
Mix and match - Combine servers for unique workflows
Vendor agnostic - MCP is an open standard, not proprietary
Community powered - New servers added weekly

📥 Expandable INPUTS: What You Can Capture

Current Built-In Capabilities:

✅ YouTube Videos → Transcripts + summaries
✅ GitHub Repositories → Code analysis + documentation
✅ Web Articles → Clean text extraction
✅ Quick Ideas → AI-tagged notes
✅ Text Content → Direct capture

Add These MCP Servers to Capture More:

📸 Visual & Media Analysis

Image Analysis → Extract text, identify objects, describe scenes
- Server: mcp/vision-analysis, mcp/ocr-engine
- Use case: Screenshot docs, photos of whiteboards, diagrams
Audio Transcripts → Convert podcasts, meetings, voice memos to text
- Server: mcp/whisper-api, mcp/assembly-ai
- Use case: Interview recordings, lecture notes, brainstorming sessions
Video Analysis → Keyframe extraction, scene detection, content summarization
- Server: mcp/video-intelligence, mcp/frame-extractor
- Use case: Tutorial videos, conference talks, product demos
PDF Extraction → Parse complex PDFs with tables, images, formatting
- Server: mcp/pdf-parser (already available via document-skills)
- Use case: Research papers, reports, invoices, contracts

📚 Research & Academia

Academic Papers → Structured extraction from arXiv, PubMed, Google Scholar
- Server: mcp/arxiv-fetcher, mcp/semantic-scholar
- Use case: Literature reviews, research synthesis
Email Archives → Gmail/Outlook thread analysis and extraction
- Server: mcp/gmail-api, mcp/outlook-connector
- Use case: Project communication, client correspondence
RSS Feeds → Automated article monitoring and summarization
- Server: mcp/rss-aggregator, mcp/feed-reader
- Use case: Industry news, competitor tracking, topic monitoring

💼 Business & Productivity

Slack/Discord → Conversation archival and search
- Server: mcp/slack-history, mcp/discord-logger
- Use case: Team knowledge, decision trails, meeting summaries
Cloud Storage → Index files from Dropbox, Google Drive, OneDrive
- Server: mcp/gdrive-indexer, mcp/dropbox-sync
- Use case: Document library, shared knowledge
Database Queries → Extract insights from SQL/NoSQL databases
- Server: mcp/postgres, mcp/sqlite, mcp/mongodb
- Use case: Analytics data, customer records, metrics

Twitter/X Threads → Archive important threads and conversations
- Server: mcp/twitter-api, mcp/thread-unroller
- Use case: Expert insights, industry discussions
Reddit Discussions → Capture high-value threads and AMAs
- Server: mcp/reddit-archiver
- Use case: Community wisdom, product research
LinkedIn Posts → Professional content and thought leadership
- Server: mcp/linkedin-fetcher
- Use case: Industry trends, expert opinions

📤 Expandable OUTPUTS: What You Can Create

Current Built-In Capabilities:

✅ Markdown Documents → Clean, portable notes
✅ HTML Pages → Published to GitHub Pages
✅ Git Commits → Version-controlled knowledge

Add These MCP Servers to Create More:

📊 Visual Creation

Flowcharts & Diagrams → Mermaid, PlantUML, draw.io
- Server: mcp/mermaid-renderer, mcp/plantuml-engine
- Use case: Process documentation, system architecture, mind maps
Image Generation → AI-generated images from descriptions
- Server: mcp/dalle-api, mcp/stable-diffusion, mcp/midjourney-bridge
- Use case: Article illustrations, concept visualization, mockups
Infographics → Data visualization and presentation graphics
- Server: mcp/chartjs-generator, mcp/plotly-engine
- Use case: Reports, presentations, social media content

📝 Document Creation

DOCX Documents → Professional Word documents with formatting
- Server: mcp/docx-generator (available via document-skills)
- Use case: Reports, proposals, documentation
XLSX Spreadsheets → Excel files with formulas and charts
- Server: mcp/xlsx-builder (available via document-skills)
- Use case: Budget planning, data analysis, project tracking
PPTX Presentations → PowerPoint decks with themes and layouts
- Server: mcp/pptx-creator (available via document-skills)
- Use case: Pitch decks, training materials, conference talks
PDF Reports → Publication-ready PDFs with professional layouts
- Server: mcp/pdf-generator (available via document-skills)
- Use case: White papers, case studies, portfolios

📈 Business Intelligence

Financial Dashboards → Interactive charts for revenue, costs, metrics
- Server: mcp/dashboard-builder, mcp/metabase-api
- Use case: Business analytics, KPI tracking, investor reports
Kanban Boards → Visual task management and project tracking
- Server: mcp/kanban-generator, mcp/trello-sync
- Use case: Sprint planning, workflow visualization, team coordination
Gantt Charts → Project timelines and dependency mapping
- Server: mcp/gantt-creator, mcp/mermaid-gantt
- Use case: Project planning, resource allocation, milestone tracking
Data Analysis → SQL queries, statistical analysis, ML predictions
- Server: mcp/pandas-engine, mcp/jupyter-runner
- Use case: Research analysis, business intelligence, forecasting

🎨 Creative & Multimedia

Video Generation → AI-generated videos from scripts or images
- Server: mcp/runway-api, mcp/video-assembler
- Use case: Tutorial videos, marketing content, animations
Audio Synthesis → Text-to-speech, voiceovers, podcast creation
- Server: mcp/elevenlabs-api, mcp/audio-generator
- Use case: Audiobooks, narrations, accessibility
Code Generation → Auto-generate code from descriptions
- Server: mcp/codegen-assistant, mcp/github-copilot-bridge
- Use case: Prototyping, boilerplate code, documentation examples

🌍 Publishing & Distribution

Blog Posts → Automated posting to WordPress, Medium, Ghost
- Server: mcp/wordpress-publisher, mcp/medium-api
- Use case: Content distribution, SEO optimization
Social Media → Cross-post to Twitter, LinkedIn, Facebook
- Server: mcp/social-autoposter, mcp/buffer-api
- Use case: Thought leadership, content marketing
Email Newsletters → Format and send via Mailchimp, SendGrid
- Server: mcp/newsletter-builder, mcp/sendgrid-api
- Use case: Audience engagement, knowledge sharing

🔧 Example Expansion Workflows

Workflow 1: Research Paper → Publication Pipeline

CAPTURE: Extract PDF → mcp/pdf-parser
ANALYZE: Summarize findings → Claude AI
VISUALIZE: Create charts → mcp/plotly-engine
GENERATE: Write blog post → /capture + formatting
ILLUSTRATE: AI-generated header image → mcp/dalle-api
PUBLISH: Post to Medium → mcp/medium-api

Workflow 2: Meeting → Action Items Dashboard

CAPTURE: Transcribe audio → mcp/whisper-api
EXTRACT: Identify action items → Claude AI
ORGANIZE: Create Kanban board → mcp/kanban-generator
TRACK: Build Gantt chart → mcp/gantt-creator
SHARE: Export to XLSX → mcp/xlsx-builder
DISTRIBUTE: Email to team → mcp/sendgrid-api

Workflow 3: Product Idea → Pitch Deck

CAPTURE: Voice memo brainstorm → mcp/whisper-api
STRUCTURE: Organize ideas → Claude AI + templates
RESEARCH: Market analysis → mcp/web-search + databases
VISUALIZE: Create mockups → mcp/dalle-api
BUILD: Generate pitch deck → mcp/pptx-creator
FINALIZE: Export to PDF → mcp/pdf-generator

🎯 How to Expand Your Factory

Step 1: Browse the MCP Catalog

# Docker Desktop → MCP Toolkit → Catalog
# Search for capability (e.g., "image generation")
# Preview server documentation and features

Step 2: Install with One Click

# Click "Add" on desired server
# Configure API keys if required
# Server is immediately available in Claude Code

Step 3: Use New Capabilities

# Example: After installing mcp/dalle-api
mcp__dalle__generate_image "A minimalist knowledge factory diagram"

# Example: After installing mcp/whisper-api
mcp__whisper__transcribe_audio "/path/to/meeting.mp3"

Step 4: Create Custom Workflows

# Combine servers in slash commands (via obsidian-vault-manager)
# Chain outputs: PDF → Analysis → Visualization → Publication
# Build repeatable processes for common tasks

💡 Why This Matters

Traditional tools lock you into their feature set. When you need image generation, you buy Midjourney. Need spreadsheets? Buy Excel. Need project management? Buy Jira.

KnowledgeFactory is different. It’s a platform, not a product. You start with core knowledge management, then add capabilities as your needs evolve:

✅ Week 1: Basic note capture ✅ Month 1: Add YouTube + GitHub extraction ✅ Month 3: Add image analysis for research papers ✅ Month 6: Add flowchart generation for documentation ✅ Year 1: Add video creation for tutorials

Your factory grows organically with your knowledge work. No migration. No data loss. No vendor lock-in.

🌟 The Future is Modular

MCP Server Ecosystem is Growing:

300+ servers available today
New servers added weekly
Open standard (anyone can create servers)
Community-driven innovation

Your KnowledgeFactory becomes:

📥 Universal Inbox: Capture from any source
🧠 AI Processing Hub: Analyze with any model
📤 Universal Publisher: Create any output format
🔗 Integration Platform: Connect any tool

This is the power of modular architecture. Start simple. Expand infinitely.

🏭 The KnowledgeFactory Architecture

The Complete Manufacturing System

KnowledgeFactory is built from four integrated production lines:

┌─────────────────────────────────────────────────────────────────┐
│                    KNOWLEDGEFACTORY SYSTEM                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. INPUT LAYER (Multi-Channel Capture)                        │
│     • Desktop: Claude Code commands                            │
│     • Mobile: GitHub Mobile + Actions                          │
│     • Web: Browser extension (future)                          │
│     • Voice: Audio transcription (future)                      │
│                                                                 │
│  2. PROCESSING LAYER (AI Automation)                           │
│     • Claude AI: Content analysis & tagging                    │
│     • MCP Servers: Content extraction (YouTube, GitHub, Web)   │
│     • Scripts: Automation workflows                            │
│     • Templates: Consistent formatting                         │
│                                                                 │
│  3. STORAGE LAYER (Knowledge Vault)                            │
│     • Obsidian: Local-first markdown storage                   │
│     • Git: Version control & sync                              │
│     • Plugins: Enhanced capabilities                           │
│     • Graph: Visual knowledge connections                      │
│                                                                 │
│  4. OUTPUT LAYER (Discovery & Distribution)                    │
│     • Semantic Search: Find by meaning                         │
│     • GitHub Pages: Web publishing                             │
│     • Access Control: Granular permissions                     │
│     • Export: Multiple formats                                 │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Knowledge Lifecycle Stages

Stage 1: 📥 CAPTURE (Input)

Goal: Grab information from anywhere, anytime, in any format

Tools:

Claude Code commands: /capture, /youtube-note, /idea, /gitingest
GitHub Mobile + Actions: Mobile capture with AI processing
MCP Servers: YouTube transcripts, GitHub repos, web articles

Outputs: Raw markdown notes in your vault

Stage 2: 🏷️ CURATE (Processing)

Goal: Transform raw input into organized, tagged, formatted knowledge

Tools:

Claude AI: Auto-tagging (6-8 smart tags per note)
Templates: Consistent YAML frontmatter and structure
obsidian-vault-manager-plugin: Automation workflows
Bulk auto-tag: Process existing notes in batch

Outputs: Organized notes with metadata, tags, and structure

Stage 3: 🌱 NURTURE (Connection)

Goal: Build relationships between ideas, create knowledge graph

Tools:

Obsidian Graph View: Visual connection network
Smart Connections: AI-powered note linking
Backlinks: Bi-directional references
Tags: Categorical organization

Outputs: Connected knowledge web, not isolated notes

Goal: Refine ideas, add insights, structure thinking

Tools:

Obsidian Editor: Rich markdown editing
Canvas: Visual brainstorming
Study Guide Generator: /study-guide command
Templates: Pre-built structures for different content types

Outputs: Refined, well-structured knowledge assets

Stage 5: 🔄 EVOLVE (Maintenance)

Goal: Keep knowledge current, update connections, discover patterns

Tools:

Semantic Search: Find related content as knowledge grows
Git History: Track evolution over time
AI Suggestions: Discover new connections
Periodic Review: Scheduled maintenance workflows

Outputs: Evergreen knowledge that improves with time

Goal: Publish knowledge to the world with appropriate access control

Three-Tier Sensitivity Model:

KnowledgeFactory uses a two-repository architecture to maintain clear boundaries between private and shared knowledge:

┌─────────────────────────────────────────────────────────────┐
│  TIER 1: PRIVATE (Vault Repository)                         │
│  • All your notes stay in your private Obsidian vault       │
│  • Never published unless you explicitly choose             │
│  • Location: Your local vault (optionally git-tracked)      │
│  • Access: Only you                                          │
└─────────────────────────────────────────────────────────────┘
                            ↓
                    /publish command
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  TIER 2: TRUSTED CIRCLE (Sharehub with password)            │
│  • Published to GitHub Pages with password protection       │
│  • Frontmatter: access: private                             │
│  • Password: Shared with your trusted team/friends          │
│  • Use case: Internal docs, team knowledge, WIP drafts      │
└─────────────────────────────────────────────────────────────┘
                            ↓
                    Remove access: private
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  TIER 3: PUBLIC (Sharehub without password)                 │
│  • Published to GitHub Pages, no password required          │
│  • Frontmatter: No access field (or access: public)         │
│  • Anyone with link can read                                │
│  • Use case: Blog posts, tutorials, public documentation    │
└─────────────────────────────────────────────────────────────┘

Two-Repository Architecture:

Vault Repository (Private - Your Brain)
- Contains: ALL your notes (drafts, private thoughts, unfinished ideas)
- Location: ~/Documents/Obsidian/YourVault/
- Git: Optional (for backup/sync)
- Published: Never (stays on your machine)
- Purpose: Your personal knowledge factory
Sharehub Repository (Public - Your Publishing Platform)
- Contains: ONLY notes you explicitly publish via /publish
- Location: Separate directory (e.g., ~/Dev/sharehub/)
- Git: Required (pushes to GitHub Pages)
- Published: Yes (https://yourname.github.io/sharehub)
- Purpose: Public/team knowledge distribution

Why Two Repositories?

✅ Privacy by default: Vault never exposed, only selected notes published ✅ Clear separation: Draft vs. polished, private vs. shareable ✅ Selective sharing: Choose exactly what the world sees ✅ Image handling: Images copied from vault → sharehub with path conversion ✅ No accidents: Can’t accidentally publish your entire vault

Publishing Workflow:

# Your note in vault
~/Documents/Obsidian/Claudecode/my-article.md
  └── Images: ./images/diagram.png

# Run publish command
/publish my-article.md

# Script does:
1. Read note from vault
2. Copy images: vault/images/ → sharehub/images/
3. Convert paths: ./images/diagram.png → /sharehub/images/diagram.png
4. Write note: sharehub/documents/my-article.md
5. Git commit + push to sharehub repo
6. GitHub Pages deploys (60 seconds)

# Result:
https://yourname.github.io/sharehub/documents/my-article.html

Access Control via Frontmatter:

# TIER 1: Private (never publish)
# Simply don't run /publish command

# TIER 2: Trusted circle (password-protected)
---
title: "Internal Team Strategy"
access: private
---
# Requires password to view (shared with team)

# TIER 3: Public (no password)
---
title: "How to Build a Knowledge Base"
---
# Anyone can read

Tools:

/publish command: One-click publishing with two-repo architecture
Vault Repository: Your private knowledge base (never published)
Sharehub Repository: Your public/team publishing platform (GitHub Pages)
Access Control: Password protection via access: private frontmatter
Image Handling: Automatic copy and path conversion
Shareable Links: Direct URLs to published content

Outputs: Three-tier knowledge distribution (private → trusted → public)

🔧 The Complete Tool Stack

Installation Hierarchy & Dependencies

Here’s the complete tool stack organized by installation order and dependencies:

1. Foundation Layer (Install First)
   ├── Claude Pro/Max Subscription ($20-50/mo)
   │   └── Claude Code (free download, requires subscription)
   ├── Obsidian (free)
   │   └── Obsidian MCP Tools Plugin
   │       ├── MCP Server v0.2.27+
   │       ├── Local REST API (auto-installed)
   │       ├── Smart Connections (optional)
   │       └── Templater (optional)
   └── Docker Desktop (free)
       └── Docker MCP Toolkit
           └── MCP Servers (install from catalog)
               ├── Required (4 servers):
               │   ├── GitHub Official [API key required]
               │   ├── YouTube Transcripts [no key]
               │   ├── Firecrawl [API key required]
               │   └── Obsidian [no key]
               ├── Recommended (2 servers):
               │   ├── Context7 [no key]
               │   └── Fetch (Reference) [no key]
               └── Optional (2 servers):
                   ├── Memory (Reference) [no key]
                   └── Perplexity [API key required]

2. Automation Layer (Install Second)
   └── obsidian-vault-manager-plugin (via Claude Code)
       ├── Slash Commands (/capture, /youtube-note, /idea, etc.)
       ├── Skills (obsidian-vault-manager skill)
       ├── Scripts (fetch-youtube-transcript.sh, publish.sh)
       └── Templates (idea, youtube, article, repository)

3. System Tools (Install Third)
   ├── Git (required for /publish and version control)
   └── jq (required for /publish and mobile capture)

4. Optional Enhancements (Install Last)
   └── Semantic Search
       ├── Smart Connections Plugin (free or $120/yr)
       └── ChromaDB (free, self-hosted alternative)

Installation Order Summary:

Foundation → Claude subscription + Obsidian + Docker
Obsidian Plugin → MCP Tools (with dependencies)
Docker MCP Servers → Install 4-8 servers from catalog
Connect → Claude Code to Docker MCP Toolkit
Two Repositories → Private vault + Public sharehub (Git setup)
Automation Plugin → obsidian-vault-manager-plugin + setup wizard
Test → Verify all lifecycle stages work
Optional → Semantic search + Mobile capture

Layer 1: Foundation Tools (Required)

1.1 Claude Code (AI Command Center)

Purpose: Your AI assistant and command interface Version: 2.0.36+ Cost: Requires Claude Pro ($20/mo) or Claude Max ($50/mo) subscription

What it provides:

Slash command interface (/capture, /idea, /publish)
AI-powered content analysis and tagging
MCP server orchestration
Automation workflow execution

Note: Claude Code is free to download, but requires an active Claude Pro or Max subscription to use. This subscription cost is the primary expense of KnowledgeFactory.

1.2 Obsidian (Knowledge Vault)

Purpose: Your local-first markdown knowledge base Version: Latest stable release Cost: $0 (optional $25 one-time for mobile sync)

What it provides:

Markdown editor with rich preview
Graph view for knowledge connections
Plugin ecosystem for extensibility
Local-first, privacy-focused storage

Required plugins:

Obsidian MCP Tools - Enables MCP server integration
- Install: Settings → Community Plugins → Search “MCP Tools”
- Enable + Click “Install Server” button

1.3 Docker Desktop (Server Infrastructure)

Purpose: Container platform for MCP servers Version: Latest stable release Cost: $0 (free tier sufficient)

What it provides:

MCP Toolkit for server management
Easy installation of 300+ available MCP servers
Client connection management (Claude Code integration)
Server monitoring and logging

Layer 2: Docker MCP Toolkit Servers (Content Extraction)

MCP (Model Context Protocol) servers provide specialized capabilities for content extraction and processing. All servers are installed through Docker Desktop → MCP Toolkit → Catalog.

How to Install MCP Servers:

Open Docker Desktop
Click MCP Toolkit in left sidebar
Click Catalog tab (shows 300+ available servers)
Search for server name and click “Add”
Configure API keys in My servers tab (if required)
Go to Clients tab → Click “Connect” on Claude Code

Required Servers (Install All 4)

Server Name	Purpose	API Key?	Get API Key
GitHub Official	Repository analysis, commits, PRs	✅ Yes	github.com/settings/tokens Scopes: `repo`, `public_repo`
YouTube Transcripts	Video transcripts and metadata	❌ No	-
Firecrawl	Web scraping, article extraction	✅ Yes	firecrawl.dev Free tier: 1000 requests/month
Obsidian	Vault file operations	❌ No	Requires Obsidian MCP Tools plugin

Commands powered by these servers:

/gitingest <repo-url> - GitHub Official
/youtube-note <url> - YouTube Transcripts
/capture <url> - All servers (auto-detects content type)
Vault operations - Obsidian server

Recommended Servers (Install for Enhanced Features)

Server Name	Purpose	API Key?
Context7	Library documentation lookup	❌ No
Fetch (Reference)	General web content fetching	❌ No

What they enable:

Quick reference to popular library docs
Fallback web fetching for any URL
HTML to markdown conversion

Optional Servers (Install Based on Your Needs)

Server Name	Purpose	API Key?	Get API Key
Memory (Reference)	Knowledge graph across sessions	❌ No	-
Perplexity	AI-powered web search	✅ Yes	perplexity.ai/settings/api

What they enable:

Persistent memory and entity tracking (Memory)
AI-powered research and fact-checking (Perplexity)

API Key Configuration

For servers requiring API keys, configure them after installation:

Docker Desktop → MCP Toolkit → My servers tab
Click on the server name
Paste API key in the configuration field
Click “Save” and restart server
Verify green status indicator

API Keys Summary:

✅ Required: GitHub Official, Firecrawl
⭐ Optional: Perplexity (only if you install it)
❌ Not needed: YouTube, Obsidian, Context7, Fetch, Memory

Layer 3: obsidian-vault-manager-plugin (Automation Engine)

3.1 Plugin Installation

Repository: ZorroCheng-MC/obsidian-vault-manager-plugin Purpose: Slash commands, templates, and automation workflows

Installation steps:

# Start Claude Code
claude

# Add plugin marketplace
/plugin marketplace add ZorroCheng-MC/obsidian-vault-manager-plugin

# Install plugin
/plugin install obsidian-vault-manager

# Verify installation
/plugin list

3.2 Plugin Components

Slash Commands (located in commands/ directory):

/capture - Universal content capture with auto-detection
/youtube-note - YouTube video capture with transcript
/idea - Quick idea capture with AI tagging
/gitingest - GitHub repository analysis
/study-guide - Generate study materials from content
/publish - Publish notes to GitHub Pages
/semantic-search - Search vault by meaning
/bulk-auto-tag - Batch tag existing notes

Skills (located in obsidian-vault-manager/ directory):

obsidian-vault-manager skill - Main automation skill
Provides: Templates, scripts, validation

Scripts (located in obsidian-vault-manager/scripts/):

core/fetch-youtube-transcript.sh - YouTube data extraction
core/publish.sh - GitHub Pages publishing workflow
validation/validate-frontmatter.py - YAML validation

Templates (located in obsidian-vault-manager/templates/):

idea-template.md - Quick idea structure
youtube-template.md - Video note format
article-template.md - Web article structure
repository-template.md - GitHub repo analysis

Layer 4: System Dependencies (Required Tools)

4.1 Git (Version Control)

Purpose: Vault versioning, sync, and publishing Required for: /publish command, mobile sync

Installation:

# macOS
brew install git

# Linux
sudo apt install git

# Windows
# Download from: https://git-scm.com/download/win

4.2 jq (JSON Processing)

Purpose: JSON parsing in automation scripts Required for: /publish command, mobile capture workflow

Installation:

# macOS
brew install jq

# Linux
sudo apt install jq

# Windows
# Download from: https://stedolan.github.io/jq/download/

Optional Enhancements

Semantic Search Options

Option 1: Smart Connections Plugin (Recommended)

Cost: Free tier or $120/year premium
Install: Obsidian → Settings → Community Plugins → “Smart Connections”
Features: AI-powered note linking, semantic search, related notes

Option 2: ChromaDB (Free Alternative)

Cost: $0 (open-source)
Setup: Self-hosted vector database
Features: Local semantic search, full privacy

📖 Complete Getting Started Guide

Prerequisites Checklist

Before you begin, ensure you have:

Claude Pro or Claude Max subscription ($20/mo or $50/mo)
macOS, Linux, or Windows computer
Internet connection for initial setup
GitHub account (free tier is sufficient)
Basic command line familiarity (we’ll guide you through)

Time required: 45-60 minutes for complete setup

Phase 1: Install Foundation Tools (15 minutes)

Step 1.1: Install Docker Desktop

Download from: docker.com/products/docker-desktop
Run installer and follow prompts
Launch Docker Desktop
Wait for “Docker Desktop is running” indicator (green)

Step 1.2: Install Obsidian

Download from: obsidian.md
Run installer and follow prompts
Launch Obsidian
Create new vault: File → New vault
- Name: Choose any name (e.g., “KnowledgeFactory”)
- Location: Choose accessible directory (e.g., ~/Documents/Obsidian/KnowledgeFactory)
Remember this path - you’ll need it later

Step 1.3: Install Claude Code

Download from: claude.ai/code
Run installer and follow prompts
Launch Claude Code and sign in with Claude Pro/Max account
Verify connection (should show green checkmark)

Step 1.4: Install System Dependencies

# macOS
brew install git jq

# Linux
sudo apt install git jq

# Windows (via Chocolatey)
choco install git jq

Verify installation:

git --version
jq --version

Phase 2: Install Obsidian Plugins (10 minutes)

IMPORTANT: We install Obsidian plugins FIRST because the Local REST API plugin generates an API key that the Docker MCP Obsidian server needs in Phase 4.

Step 2.1: Install MCP Tools Plugin

Open Obsidian
Go to: Settings (gear icon) → Community plugins
Click Browse button
Search: “MCP Tools”
Click Install on the MCP Tools plugin
Click Enable after installation
Important: Click “Install Server” button in plugin settings
- This installs the MCP Server (v0.2.27 or later)
- Starts the Local REST API server
- Required for MCP Obsidian server to work

Verify Installation Status:

✅ MCP Server v0.2.27 is installed (or later version)
✅ Local REST API is installed
✅ Smart Connections is installed (optional but recommended)
✅ Templater is installed (optional but recommended)

Check Dependencies: The plugin settings should show:

✅ Local REST API is installed
✅ Smart Connections is installed (for semantic search)
✅ Templater is installed (for advanced templates)

Resources:

Server install folder
Server log folder (for troubleshooting)
GitHub repository (for updates and issues)

Note: Smart Connections and Templater are optional dependencies that enhance functionality but aren’t strictly required for basic operation.

Step 2.2: Install Terminal Plugin for Integrated UI (Recommended)

Why Terminal Plugin? This creates a unified workspace where you can edit notes AND run Claude Code commands in one window—no context switching between applications.

![[images/knowledgefactory-integrated-ui-terminal-plugin.png]]

Benefits of Integrated UI:

✅ No context switching - Edit notes while running AI commands in the same window
✅ Side-by-side workflow - See your notes on the left, terminal on the right
✅ Persistent terminal - Terminal stays open across Obsidian sessions
✅ Efficient capture - Run /capture, /publish, /youtube-note while viewing notes
✅ Visual organization - All knowledge work in one unified interface

Installation:

In Obsidian → Settings → Community plugins → Browse
Search: “Terminal”
Install the Terminal plugin by polyipseity
Click Enable after installation

Configuration:

Go to: Settings → Community plugins → Terminal → Plugin settings
Configure these settings:
- Shell path: Enter the path to your shell (e.g., /bin/zsh or /bin/bash)
- Default profile: Choose your preferred shell profile
- Working directory: Set to your vault path or leave default
Click Save

Usage:

Open the terminal panel:
- Ribbon: Click the terminal icon in the left ribbon, OR
- Command palette (Cmd/Ctrl+P): Type “Terminal: Open” and select it
The terminal opens in a side panel (right side by default)

Navigate to your vault:

cd ~/Documents/Obsidian/KnowledgeFactory

Start Claude Code:
```
claude
```
Now you have an integrated workspace:
- Left panel: Edit your markdown notes
- Right panel: Run Claude Code commands (/capture, /publish, etc.)

Pro Tips:

Resize the terminal panel by dragging the divider
Use Obsidian’s tab system to organize multiple notes while keeping terminal visible
Pin the terminal panel to keep it open across sessions
Create hotkeys for quick terminal access in Settings → Hotkeys → Terminal

Step 2.3: Configure Image Folder (REQUIRED)

Why this matters: Proper image folder configuration ensures that:

Images are organized in a dedicated images/ folder
The /publish command can correctly handle image paths
Your vault stays clean and organized

Configuration Steps:

In Obsidian → Settings (gear icon) → Files & Links
Find Default location for new attachments
Select: In the folder specified below
In Attachment folder path field, enter: images
Click outside the field to save

Additional Settings (Recommended):

✅ New link format: Use [[Wikilinks]] (default is fine)
✅ Use [[Wikilinks]]: Keep enabled for Obsidian-style linking

Verify Configuration:

# Check that app.json contains the correct setting
cat "$VAULT_PATH/.obsidian/app.json" | jq '.attachmentFolderPath'
# Should output: "images"

Test by Adding an Image:

Create or open a note in Obsidian
Drag and drop any image into the note
Check your vault folder - the image should be in images/ folder
The markdown link should show: ![[images/filename.png]]

Alternative (Command Line Configuration):

# Automated configuration via app.json
VAULT_PATH="$HOME/Documents/Obsidian/KnowledgeFactory"  # Use your actual path

# Create images folder
mkdir -p "$VAULT_PATH/images"

# Update app.json to set attachment folder
jq '.attachmentFolderPath = "images"' "$VAULT_PATH/.obsidian/app.json" > "$VAULT_PATH/.obsidian/app.json.tmp"
mv "$VAULT_PATH/.obsidian/app.json.tmp" "$VAULT_PATH/.obsidian/app.json"

echo "✅ Image folder configured"

Important Notes:

This setting applies to ALL new attachments (images, PDFs, etc.)
Existing images won’t be moved automatically
The /publish command expects images in the images/ folder

Phase 3: Retrieve Local REST API Key (3 minutes)

CRITICAL STEP: We need to get the Local REST API key NOW before installing Docker MCP servers, because the Obsidian MCP server requires this key for configuration.

Step 3.1: Get Local REST API Key

Open Obsidian (if not already open)
Go to: Settings (gear icon) → Community plugins
Find Local REST API in the installed plugins list
Click on Local REST API to open its settings
Look for API Key field (should show a long hexadecimal string)

Copy the API key - it looks like:

0de5ba07c38bd3250722a4978d463ab886dd507607482628794be7f8ee2bd66a

Alternative (Command Line):

# If you prefer to get the key via terminal:
VAULT_PATH="$HOME/Documents/Obsidian/KnowledgeFactory"  # Use your actual path
cat "$VAULT_PATH/.obsidian/plugins/obsidian-local-rest-api/data.json" | jq -r '.apiKey'

# Copy the output

IMPORTANT: Keep this API key safe - you’ll need it in Phase 4 to configure the Docker MCP Obsidian server.

Phase 4: Configure MCP Infrastructure (15 minutes)

Now that you have the Obsidian Local REST API key, we can configure the Docker MCP servers.

Step 4.1: Install MCP Servers via Docker Desktop

Open Docker Desktop
Click MCP Toolkit in left sidebar
Click Catalog tab (you’ll see 300+ available servers)

Install these servers (search by name and click “Add”):

Required servers:

✅ GitHub Official - Repository operations
✅ YouTube Transcripts - Video data extraction
✅ Firecrawl - Web content scraping
✅ Obsidian - Vault file operations (requires API key from Phase 3)

Recommended servers:

⭐ Context7 - Library documentation
⭐ Fetch (Reference) - General web fetching

Optional servers:

🔵 Memory (Reference) - Knowledge graph
🔵 Perplexity - AI-powered search

You should see 8 servers installed (or minimum 4 required)

Step 4.2: Configure API Keys

GitHub Official (Required):

Generate token: github.com/settings/tokens
- Click: Generate new token (classic)
- Scopes: Check repo and public_repo
- Generate and copy token
In Docker Desktop → MCP Toolkit → My servers tab
Click GitHub Official server
Paste token in API key field
Click Save and restart server

Firecrawl (Required):

Sign up: firecrawl.dev
Copy API key from dashboard (1000 free requests/month)
In Docker Desktop → MCP Toolkit → My servers tab
Click Firecrawl server
Paste API key and save

Obsidian (Required - uses API key from Phase 3):

In Docker Desktop → MCP Toolkit → My servers tab
Click Obsidian server
Look for API Key or Environment Variables section
Add the configuration:
- Key name: OBSIDIAN_LOCAL_REST_API_KEY (or apiKey)
- Value: Paste the API key you copied in Phase 3
Click Save and restart server

Perplexity (Optional):

Go to: perplexity.ai/settings/api
Generate API key
Add to Perplexity server in MCP Toolkit

Step 4.3: Connect Claude Code to MCP Toolkit

In Docker Desktop → MCP Toolkit → Clients tab
Find Claude Code in the list
Click Connect button
Wait for “Connected” status (green indicator)

Verify: All servers should show green status in My servers tab

Test Obsidian Connection:

# In Claude Code, test the Obsidian MCP connection:
mcp__obsidian-mcp-tools__get_server_info

# Should return Obsidian vault information without errors

Troubleshooting:

If Obsidian server connection fails, verify Local REST API is running in Obsidian
Check the API key was copied correctly (no extra spaces)
Ensure Obsidian is open with your vault loaded
Restart Docker MCP Obsidian server after configuration

Phase 5: Set Up Two-Repository Architecture (15 minutes)

KnowledgeFactory uses two separate Git repositories for the three-tier sensitivity model:

Private Vault Repository (TIER 1) - Your personal knowledge base
Public Sharehub Repository (TIER 2 & 3) - Your publishing platform

Step 4.1: Initialize Private Vault Repository

Your Obsidian vault becomes a private Git repository:

# Navigate to your vault
cd ~/Documents/Obsidian/KnowledgeFactory  # Use your actual vault path

# Initialize git repository
git init

# Create .gitignore to exclude system files
cat > .gitignore << 'EOF'
# Obsidian system files
.obsidian/workspace.json
.obsidian/workspace-mobile.json
.trash/

# macOS
.DS_Store

# Temp files
*.tmp
EOF

# Initial commit
git add .
git commit -m "Initial commit: Private knowledge vault

🧠 KnowledgeFactory private vault initialized
This vault contains all my personal notes and knowledge.
Only selected notes will be published to sharehub.

🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>"

Optional: Push to GitHub (as private repository)

# Create private GitHub repository
gh repo create my-knowledge-vault --private --source=. --push

# Or manually:
# 1. Go to github.com/new
# 2. Create private repository "my-knowledge-vault"
# 3. Add remote and push:
git remote add origin https://github.com/YOUR_USERNAME/my-knowledge-vault.git
git push -u origin main

Note: This vault stays private. It’s for backup and sync only, never published to GitHub Pages.

Step 4.2: Set Up Sharehub Publishing Platform

Sharehub is a pre-configured Jekyll-based publishing platform with GitHub Actions workflows for automatic deployment.

Quick setup (5 minutes):

# Clone the template
cd ~/Documents
git clone https://github.com/ZorroCheng-MC/sharehub.git
cd sharehub

# Initialize as your own repository
rm -rf .git
git init
git add .
git commit -m "Initial commit: My KnowledgeFactory sharehub"

# Create GitHub repository and push
gh repo create my-sharehub --public --source=. --push

# Enable GitHub Pages
gh repo edit --enable-pages --pages-branch main

# Configure Jekyll baseurl (edit _config.yml)
# Change: baseurl: "/my-sharehub"  (to match YOUR repo name)
git add _config.yml
git commit -m "Configure Jekyll baseurl"
git push

# Verify: Visit https://YOUR_USERNAME.github.io/my-sharehub

What you get:

✅ Pre-configured Jekyll + GitHub Actions workflow
✅ Tag-based access control (Tier 2 & 3)
✅ Password protection built-in
✅ Auto-deploy on push (~1 minute)

📖 For complete setup instructions, troubleshooting, and manual upload:

See: Sharehub Setup Guide

The sharehub README covers:

Step-by-step setup (with both CLI and manual options)
Jekyll baseurl configuration details
GitHub Pages deployment verification
Manual document upload (alternative to /publish)
Troubleshooting common issues
Tag-based access control explanation

Step 4.3: Record Repository Paths

You now have two repositories:

Private Vault (Tier 1 - Never Published):
  Path: ~/Documents/Obsidian/KnowledgeFactory
  Git: git@github.com:YOUR_USERNAME/my-knowledge-vault.git (private)
  Purpose: Your personal knowledge factory

Public Sharehub (Tier 2 & 3 - Publishing Platform):
  Path: ~/Documents/sharehub
  Git: git@github.com:YOUR_USERNAME/my-sharehub.git (public)
  Web: https://YOUR_USERNAME.github.io/my-sharehub
  Purpose: Knowledge distribution

Important Notes:

📝 Remember both paths - You’ll provide them to the /setup wizard in Phase 5
🔧 Setup wizard configures everything - Creates .claude/config.sh with your paths
✅ No manual editing needed - The /publish command reads from config automatically

Phase 6: Install obsidian-vault-manager-plugin (10 minutes)

Step 6.1: Add Plugin to Claude Code

# Navigate to your VAULT (not sharehub!)
cd ~/Documents/Obsidian/KnowledgeFactory

# Start Claude Code
claude

In Claude Code, run:

# Add plugin marketplace
/plugin marketplace add ZorroCheng-MC/obsidian-vault-manager-plugin

# Install the plugin
/plugin install obsidian-vault-manager

# Verify installation
/plugin list

You should see obsidian-vault-manager in the plugin list.

Step 5.2: Run Setup Wizard

In Claude Code, run:

/setup

The setup wizard will:

✅ Auto-detect your Obsidian vault path
✅ Check for git and jq dependencies
✅ Generate configuration files:
- .claude/settings.local.json - Plugin configuration
- .claude/config.sh - Script settings
✅ Validate MCP server connections
✅ Test permissions and access

Follow the prompts and provide:

Vault path confirmation (usually auto-detected)
- Example: /Users/yourname/Documents/Obsidian/KnowledgeFactory
Sharehub repository path (required for /publish command)
- Example: /Users/yourname/Documents/sharehub
- This should be the EXACT path where you cloned sharehub in Step 4.2
GitHub sharehub repository URL (required for publishing)
- Example: https://github.com/YOUR_USERNAME/sharehub
- Used for git operations and generating published URLs
GitHub Pages URL (generated automatically)
- Example: https://YOUR_USERNAME.github.io/sharehub
- Where your published notes will be accessible
Preferred tags taxonomy (or use defaults)
- Option: Use default KnowledgeFactory taxonomy
- Option: Customize your own tags

The wizard will create configuration files:

.claude/settings.local.json:

{
  "vault_path": "/Users/yourname/Documents/Obsidian/KnowledgeFactory",
  "sharehub_path": "/Users/yourname/Dev/sharehub",
  "sharehub_repo": "YOUR_USERNAME/my-sharehub",
  "github_pages_url": "https://YOUR_USERNAME.github.io/my-sharehub"
}

.claude/config.sh:

#!/bin/bash
VAULT_PATH="/Users/yourname/Documents/Obsidian/KnowledgeFactory"
SHAREHUB_PATH="/Users/yourname/Documents/sharehub"
SHAREHUB_REPO="YOUR_USERNAME/my-sharehub"
GITHUB_PAGES_URL="https://YOUR_USERNAME.github.io/my-sharehub"

Note: The /publish script reads these paths from .claude/config.sh automatically.

Verify: You should see “✅ Setup complete!” message with both repository paths confirmed.

Phase 7: Test Your KnowledgeFactory (10 minutes)

Now let’s test each stage of the knowledge lifecycle:

Test 1: Capture Stage (YouTube Video)

/youtube-note https://www.youtube.com/watch?v=dQw4w9WgXcQ

Expected result:

New note created in vault
YAML frontmatter with metadata
Full video transcript included
6-8 auto-generated tags
Structured summary

Check in Obsidian: Note should appear immediately

Test 2: Capture Stage (GitHub Repository)

/gitingest https://github.com/ZorroCheng-MC/obsidian-vault-manager-plugin

Expected result:

Repository analysis note created
Directory structure included
Code overview and documentation
Auto-tagged appropriately

Test 3: Capture Stage (Quick Idea)

/idea Build a browser extension that automatically captures highlighted text to my vault

Expected result:

Idea note created with template
AI-generated tags (e.g., [idea, browser-extension, automation, productivity])
Structured format with sections

Test 4: Curate Stage (Bulk Auto-Tag)

/bulk-auto-tag "*.md"

Expected result:

Existing notes processed with AI tagging
Tags added to frontmatter
Consistent formatting applied

First, add to a note’s frontmatter:

---
title: "My First Published Note"
tags: [test, publishing]
date: 2025-11-11
access: public
---

Then publish:

/publish my-first-note.md

Expected result:

Note committed to GitHub
Deployed to GitHub Pages
Shareable URL provided

Phase 8: Configure Semantic Search (Optional, 10 minutes)

Option A: Install Smart Connections Plugin

Open Obsidian → Settings → Community plugins
Search: “Smart Connections”
Install and enable
Configure API key (optional for premium features)

Test semantic search:

/semantic-search "notes about productivity and automation"

Option B: Set up ChromaDB (Advanced)

Follow ChromaDB documentation for self-hosted setup
Configure vector embeddings
Index your vault

Phase 9: Configure Mobile Capture (Optional, 15 minutes)

To enable mobile capture via GitHub Mobile + Actions:

Step 7.1: Create GitHub Repository for Your Vault

cd /path/to/your/vault

# Initialize git (if not already done)
git init

# Create GitHub repository (via gh CLI or web interface)
gh repo create my-knowledgefactory --private --source=. --push

Step 7.2: Add GitHub Actions Workflow

Create .github/workflows/mobile-capture.yml:

name: Mobile Capture

on:
  issues:
    types: [opened, labeled]
  issue_comment:
    types: [created]

jobs:
  capture:
    runs-on: ubuntu-latest
    if: |
      (github.event.issue && contains(github.event.issue.labels.*.name, 'capture')) ||
      (github.event.comment && contains(github.event.comment.body, '@claude'))

    steps:
      - uses: actions/checkout@v3

      - name: Process Capture
        uses: anthropics/claude-code-action@v1
        with:
          anthropic-api-key: $
          prompt: |
            Create a note from this GitHub issue with AI auto-tagging:

            Title: $
            Body: $

            Use the obsidian-vault-manager-plugin tagging taxonomy.

      - name: Commit Note
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add *.md
          git commit -m "📱 Mobile capture: $"
          git push

      - name: Comment Success
        uses: actions/github-script@v6
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: '✅ Note captured successfully!'
            })

Step 7.3: Add Anthropic API Key Secret

Go to GitHub repository settings
Secrets and variables → Actions
Click New repository secret
Name: ANTHROPIC_API_KEY
Value: Your Anthropic API key (from console.anthropic.com)
Click Add secret

Step 7.4: Test Mobile Capture

Install GitHub Mobile app on your phone
Open your vault repository
Create new issue:
- Title: “Test mobile capture”
- Body: “This is a test note from my phone”
- Add label: capture
Wait 30-60 seconds for GitHub Actions to process
Check issue for “✅ Note captured successfully!” comment
On desktop: git pull to sync the new note

You’re now fully set up! 🎉

🎯 Daily Workflow Examples

Morning Research Session

# Start Claude Code in your vault
cd ~/Documents/Obsidian/KnowledgeFactory
claude

# Capture interesting YouTube video
/youtube-note https://youtube.com/watch?v=abc123

# Capture GitHub repo you discovered
/gitingest https://github.com/user/interesting-project

# Capture article you're reading
/capture https://medium.com/interesting-article

# Quick idea that came to mind
/idea Use AI to automatically summarize daily Slack messages

# Search for related notes
/semantic-search "AI automation and productivity tools"

Result: 4 new notes, all tagged, organized, searchable in < 5 minutes

Mobile Commute Capture

See interesting video on Twitter → Share to GitHub Mobile
Open GitHub Mobile → Create issue → Paste link → Add "capture" label
60 seconds later → Note ready in vault
Evening: git pull → Note appears in Obsidian

Weekly Knowledge Review

# Find notes from this week
/semantic-search "notes created this week"

# Review and refine
# (Edit in Obsidian, add connections, update tags)

# Generate study guide from key learnings
/study-guide weekly-learnings.md

# Publish best insights to share with team
/publish weekly-insights.md

---
title: "Our New Authentication Strategy"
tags: [security, architecture, team, reference]
access: team
---

# Authentication Strategy

[Your refined knowledge here]

/publish authentication-strategy.md

Share the generated URL with your team → They have instant access

💡 What Makes KnowledgeFactory Different?

Comparison: KnowledgeFactory vs. Traditional Tools

Feature	Notion	Obsidian	Roam	LogSeq	KnowledgeFactory
Lifecycle Coverage	Partial	Manual	Manual	Manual	Complete & Automated
Capture	Manual	Manual	Manual	Manual	Multi-channel + AI
Curate	Manual	Manual	Manual	Manual	AI Auto-tag
Nurture	Manual links	Manual links	Auto-link	Auto-link	AI + Graph
Develop	Manual	Manual	Manual	Manual	AI-assisted
Evolve	Manual	Manual	Manual	Manual	Semantic search
Share	Built-in	$8/mo	$15/mo	❌ None	One-command
Cost	$8-15/mo	$0-8/mo	$15/mo	$0	$0-20/mo
Mobile	App	$25 sync	App	App	GitHub Mobile
Privacy	Cloud	Local	Cloud	Local	Local-first
AI-Powered	Basic	Plugins	❌ No	❌ No	Full Stack

Unique Value Propositions

Complete Lifecycle Management: Only tool covering capture → curate → nurture → develop → evolve → share
AI Automation at Every Stage: Not just capture, but curation, connection, and evolution
Factory Mentality: Zero waste - every input becomes findable, usable knowledge
Slash Command Power: Natural language commands for complex workflows
Open Architecture: Every component is replaceable, extensible, auditable
Cost Efficiency: 90% cheaper than traditional solutions with 10x automation
Privacy-First: Local-first storage, you control everything
Future-Proof: Built on open standards (Markdown, Git, MCP)

💰 Total Cost of Ownership

Annual Cost Comparison

Traditional PKM Setup (Typical):

Notion subscription         : $144/year
Smart Connections          : $120/year
GitHub Pro                 : $48/year
Mobile app subscription    : $36/year
Cloud storage              : $60/year
──────────────────────────────────────
Total                      : $408/year

KnowledgeFactory (Minimal):

Claude Pro subscription    : $240/year (or $0 if already subscribed)
Obsidian                   : $0 (free forever)
Docker Desktop             : $0 (free tier)
MCP Servers                : $0 (open-source)
obsidian-vault-manager     : $0 (open-source)
Git/GitHub                 : $0 (free tier)
Smart Connections          : $0 (optional: $120 for premium)
Mobile capture API         : $36/year ($3/mo) or $0 with Claude Max
──────────────────────────────────────
Total                      : $240-276/year (or $0-36 if have Claude Pro)

Savings: $132-408/year (32-100% reduction)

If you already have Claude Pro/Max:

Effective cost: $0-36/year
Savings: $372-408/year (91-100% reduction)

🚀 Roadmap & Future Vision

Current Status: v1.0 (Production Ready) ✅

What’s working now:

✅ Complete lifecycle automation (all 6 stages)
✅ Desktop capture via slash commands
✅ Mobile capture via GitHub Mobile + Actions
✅ AI auto-tagging with taxonomy
✅ Semantic search integration
✅ One-command publishing
✅ MCP server integration (8 servers)
✅ Obsidian plugin ecosystem

Planned Enhancements

Phase 2: Enhanced Input Layer (Q2 2025)

Browser extension for one-click capture
Voice recording with transcription
Email-to-vault integration
Automated RSS feed capture

Phase 3: Advanced AI Processing (Q3 2025)

GPT-4 Vision for image analysis
Automatic summary generation
Intelligent note merging
Duplicate detection

Phase 4: Collaboration Features (Q4 2025)

Team vaults with RBAC
Comment threads on notes
Shared knowledge graphs
Real-time collaboration (operational transform)

Phase 5: Enterprise Features (2026)

SSO integration (Google, Microsoft, Okta)
Advanced access control
Audit logging and compliance
On-premise deployment options

💬 Frequently Asked Questions

Q: How is KnowledgeFactory different from just using Obsidian? A: Obsidian is the storage layer. KnowledgeFactory adds AI-powered automation for the entire knowledge lifecycle - capture, curate, nurture, develop, evolve, and share. Without KF, you do all this manually.

Q: Why “Factory” in the name? A: Because it’s a manufacturing system for knowledge. Raw information enters, automated processes organize and refine it, quality control ensures consistency, and finished knowledge products are delivered. Like a factory, but for ideas.

Q: Do I need all 8 MCP servers? A: Minimum 4 required (GitHub, YouTube, Firecrawl, Obsidian). Others enhance capabilities but aren’t essential. Start with required servers, add others as needed.

Q: Can I use this without Claude Pro? A: No. Claude AI is the intelligence that powers automation at every stage. The quality of Claude’s analysis, tagging, and synthesis is what makes the factory work.

Q: Is my data private? A: Yes. Your vault is local markdown files. Claude API only sees content you explicitly send for processing. No telemetry, no tracking, no cloud storage of your notes.

Q: How long does setup take? A: 45-60 minutes for complete setup following our guide. Most time is installing MCP servers and configuring API keys. Actual plugin setup is 10 minutes.

Q: Can I customize the automation workflows? A: Yes! The obsidian-vault-manager-plugin is open source. Edit slash commands, modify templates, adjust tagging taxonomy. Fork and customize to your needs.

Q: What happens if I stop using Claude Pro? A: You lose AI automation (auto-tagging, content analysis, semantic enhancements). But your vault remains fully functional as standard Obsidian with all your markdown files intact. No lock-in.

Q: Can teams use this? A: Currently optimized for individual use. Team features (shared vaults, collaboration) planned for Phase 4. For now, you can share published notes via URLs.

Q: How does mobile capture work? A: Create GitHub issue from mobile → GitHub Actions triggers → Claude AI processes → Note committed to vault → git pull on desktop. Takes ~60 seconds, works on any device with GitHub Mobile.

Q: I have 5000 unorganized notes. Can KF help? A: Absolutely! Run /bulk-auto-tag "**/*.md" to process all existing notes with AI tagging. Then semantic search makes everything instantly findable by meaning, not just keywords. This is exactly what KF solves.

Q: What if a link/tool in the stack changes? A: That’s the beauty of open architecture. Each component is replaceable:

Claude → Gemini/Ollama/GPT-4
Obsidian → Any markdown editor
GitHub → GitLab/Gitea
MCP servers → Custom implementations

You own the system, not the vendors.

📚 Resources & Documentation

🎯 Vision: The Future of Knowledge Work

Where We’re Going

KnowledgeFactory represents a fundamental shift in how humans manage knowledge:

Traditional Approach (Manual Labor):

Human does everything → Exhausted → Low output → Most knowledge lost

KnowledgeFactory Approach (Automated Manufacturing):

Human captures → AI processes → Human refines → AI distributes → Maximum value

The Goal

Every knowledge worker should have:

✅ Zero organizing fatigue - AI handles the boring work
✅ Total recall - Find anything instantly by meaning
✅ Effortless sharing - One command from thought to publication
✅ Complete privacy - Your data stays yours forever
✅ No vendor lock-in - Own the tools, own the process
✅ Continuous improvement - Knowledge evolves automatically

Without:

❌ Monthly subscriptions
❌ Cloud dependencies
❌ Manual organization
❌ Proprietary formats
❌ Platform risk

Join the Factory Revolution

KnowledgeFactory is:

✅ Free forever (open-source)
✅ Privacy-first (local-first architecture)
✅ AI-powered (intelligent automation)
✅ Production-ready (working today)
✅ Community-driven (contributions welcome)

Start manufacturing your knowledge today.

KnowledgeFactory: Transform Information into Insight, Automatically

📋 Document Metadata

Version: 2.0 (Lifecycle Framework Edition) Last Updated: 2025-11-11 Authors: KnowledgeFactory Community License: MIT (same as obsidian-vault-manager-plugin) Status: Production Ready

Changes from v1.0:

✅ Complete perspective shift: From “tool” to “lifecycle framework”
✅ Six-stage lifecycle: Capture → Curate → Nurture → Develop → Evolve → Share
✅ Comprehensive tool inventory: All components documented with purpose, cost, setup
✅ MCP server details: Each server explained with API key requirements
✅ Complete setup guide: Step-by-step from zero to working factory (45-60 min)
✅ Factory metaphor throughout: Manufacturing system for knowledge
✅ Tool stack breakdown: Four layers with dependencies and integration
✅ Phase-by-phase installation: Clear progression with verification steps
✅ Daily workflow examples: Real-world usage patterns
✅ Enhanced comparison table: Shows lifecycle coverage advantage

Reading Time: 40-45 minutes (complete guide) | 10 minutes (overview only) Target Audience: Knowledge workers who want to automate their entire knowledge workflow Next Review: After Phase 2 features ship (Q2 2025)

KnowledgeFactory - Your AI-Powered 2nd Brain

🧠 What is KnowledgeFactory?

🎯 Why KnowledgeFactory?

The Problem: Broken Knowledge Workflow

The Solution: Automated Knowledge Factory

🚀 Infinite Expandability: Your Factory Grows With You

🎯 The MCP Advantage

📥 Expandable INPUTS: What You Can Capture

📸 Visual & Media Analysis

📚 Research & Academia

💼 Business & Productivity

🌐 Social & Web

📤 Expandable OUTPUTS: What You Can Create

📊 Visual Creation

📝 Document Creation

📈 Business Intelligence

🎨 Creative & Multimedia

🌍 Publishing & Distribution

🔧 Example Expansion Workflows

🎯 How to Expand Your Factory

💡 Why This Matters

🌟 The Future is Modular

🏭 The KnowledgeFactory Architecture

The Complete Manufacturing System

Knowledge Lifecycle Stages

Stage 1: 📥 CAPTURE (Input)

Stage 2: 🏷️ CURATE (Processing)

Stage 3: 🌱 NURTURE (Connection)

Stage 4: 🔨 DEVELOP (Refinement)

Stage 5: 🔄 EVOLVE (Maintenance)

Stage 6: 🌐 SHARE (Distribution)

🔧 The Complete Tool Stack

Installation Hierarchy & Dependencies

Layer 1: Foundation Tools (Required)

1.1 Claude Code (AI Command Center)

1.2 Obsidian (Knowledge Vault)

1.3 Docker Desktop (Server Infrastructure)

Layer 2: Docker MCP Toolkit Servers (Content Extraction)

How to Install MCP Servers:

Required Servers (Install All 4)

Recommended Servers (Install for Enhanced Features)

Optional Servers (Install Based on Your Needs)

API Key Configuration

Layer 3: obsidian-vault-manager-plugin (Automation Engine)

3.1 Plugin Installation

3.2 Plugin Components

Layer 4: System Dependencies (Required Tools)

4.1 Git (Version Control)

4.2 jq (JSON Processing)

Optional Enhancements

Semantic Search Options

📖 Complete Getting Started Guide

Prerequisites Checklist

Phase 1: Install Foundation Tools (15 minutes)

Step 1.1: Install Docker Desktop

Step 1.2: Install Obsidian

Step 1.3: Install Claude Code

Step 1.4: Install System Dependencies

Phase 2: Install Obsidian Plugins (10 minutes)

Step 2.1: Install MCP Tools Plugin

Step 2.2: Install Terminal Plugin for Integrated UI (Recommended)

Step 2.3: Configure Image Folder (REQUIRED)

Phase 3: Retrieve Local REST API Key (3 minutes)

Step 3.1: Get Local REST API Key

Phase 4: Configure MCP Infrastructure (15 minutes)

Step 4.1: Install MCP Servers via Docker Desktop

Step 4.2: Configure API Keys

Step 4.3: Connect Claude Code to MCP Toolkit

Phase 5: Set Up Two-Repository Architecture (15 minutes)

Step 4.1: Initialize Private Vault Repository

Step 4.2: Set Up Sharehub Publishing Platform

Step 4.3: Record Repository Paths

Phase 6: Install obsidian-vault-manager-plugin (10 minutes)

Step 6.1: Add Plugin to Claude Code

Step 5.2: Run Setup Wizard

Phase 7: Test Your KnowledgeFactory (10 minutes)

Test 1: Capture Stage (YouTube Video)

Test 2: Capture Stage (GitHub Repository)

Test 3: Capture Stage (Quick Idea)

Test 4: Curate Stage (Bulk Auto-Tag)