Personal Knowledge Base Agent

An agent that transforms your scattered notes, bookmarks, highlights, and fleeting ideas into a structured, interconnected knowledge base. It integrates with Obsidian, Notion, and other note-taking platforms to organize information using proven methodologies like Zettelkasten and progressive summarization. The agent discovers hidden connections between your notes, suggests when new information relates to existing knowledge, and ensures nothing valuable gets lost in the noise of daily information consumption.

Supported Platforms & Integrations

Platform	Integration Type	Features
Obsidian	Vault Management	Creates and links markdown notes, manages tags, generates graph-friendly backlinks and MOCs
Notion	Database Sync	Organizes entries into Notion databases with properties, relations, and filtered views
Readwise	Highlight Import	Pulls book and article highlights into your knowledge base with source attribution
Raindrop.io	Bookmark Import	Imports saved bookmarks with tags and organizes them into knowledge areas
Pocket	Read-Later Import	Processes saved articles, extracts key ideas, and files them into relevant topics
DEVONthink	Document Index	Indexes PDFs, documents, and research papers for full-text search and cross-referencing

When to Use

• Organizing years of scattered notes — imports notes from multiple sources, deduplicates, tags, and links them into a coherent structure
• Building a second brain for a specific domain — creates a comprehensive knowledge structure for a field you are studying or working in professionally
• Processing reading highlights — transforms raw highlights from books and articles into atomic notes with your own commentary and connections
• Preparing for writing projects — assembles relevant notes, research, and ideas into an outline-ready collection for blog posts, articles, or books
• Discovering connections between ideas — analyzes your existing notes to surface non-obvious relationships between concepts from different domains
• Weekly knowledge review — generates a digest of recently added notes, suggests connections to review, and identifies orphan notes that need linking

Alternatives to Consider

• Use Obsidian or Notion alone if your note volume is low (under 200 notes) and you enjoy manual organization as a thinking process
• Use Readwise Reader if your primary need is processing reading highlights rather than building a broader knowledge base
• Use a physical notebook if tactile writing aids your thinking process and digital tools feel like friction rather than assistance

Quick Start

Copy
agent: personal-knowledge-base-agent
config:
  primary_platform: "obsidian"
  vault_path: "~/Documents/Knowledge"
  methodology: "zettelkasten"
  import_sources:
    - readwise
    - raindrop
  daily_note: true
  weekly_review: true
  auto_link: true
  knowledge_areas:
    - software_engineering
    - product_management
    - behavioral_psychology

Example Prompt

I have 500+ notes in Obsidian but they're a mess. No consistent 
tags, very few links, and I can't find anything. I mainly take 
notes on software architecture, leadership, and psychology. 
Help me restructure my vault using Zettelkasten principles.

Example Output

## Vault Restructuring Plan
Methodology: Modified Zettelkasten | Notes analyzed: 523

### Phase 1: Taxonomy & Tagging (Automated)
- Created 12 top-level Maps of Content (MOCs):
  - Software Architecture MOC (87 notes linked)
  - Leadership & Management MOC (64 notes linked)
  - Psychology & Behavior MOC (52 notes linked)
  - ...
- Applied consistent tags: #concept, #reference, #project, #idea
- Identified 43 orphan notes needing manual review

### Phase 2: Connection Discovery
- Found 156 potential cross-links between existing notes
- Top connections to review:
  1. "Conway's Law" ↔ "Team Topology Patterns" (architecture + leadership)
  2. "Cognitive Load Theory" ↔ "API Design Principles" (psychology + architecture)
  3. "Intrinsic Motivation" ↔ "Engineering Culture" (psychology + leadership)

### Phase 3: Structural Templates
- Literature Note template (for book/article processing)
- Evergreen Note template (for mature, linked ideas)
- Project Note template (for active work contexts)
...

Advanced Configuration

Platform-Specific Settings

Copy
obsidian:
  vault_path: "~/Documents/Knowledge"
  template_folder: "_templates"
  daily_notes_folder: "daily"
  moc_folder: "_MOCs"
  use_dataview: true
  use_frontmatter: true
  tag_style: "nested"  # e.g., #area/software/architecture

readwise:
  sync_frequency: "daily"
  highlight_format: "atomic"  # one note per highlight vs. grouped
  include_tags: true
  include_notes: true

notion:
  database_id: "your-db-id"
  property_mapping:
    status: "select"
    area: "multi_select"
    source: "url"
    created: "date"

Parameters Reference

Parameter	Type	Default	Description
primary_platform	string	required	Main note platform: obsidian, notion, markdown_files
methodology	string	"zettelkasten"	Organization method: zettelkasten, para, johnny_decimal, custom
vault_path	string	required	Path to Obsidian vault or notes directory
auto_link	boolean	true	Automatically suggest and create links between related notes
daily_note	boolean	true	Generate a daily note template for capturing fleeting ideas
weekly_review	boolean	true	Generate weekly review prompts highlighting unprocessed notes
import_sources	array	[]	External sources to import: readwise, raindrop, pocket, devonthink
knowledge_areas	array	[]	Primary knowledge domains for MOC generation
note_types	array	["fleeting", "literature", "evergreen"]	Note classification types to use
link_threshold	number	0.7	Similarity threshold for auto-link suggestions (0-1)
orphan_alert_days	number	14	Alert for unlinked notes older than this many days
archive_stale_days	number	90	Suggest archiving untouched notes after this period

Core Concepts

Concept	Description
Atomic Notes	Each note captures exactly one idea, concept, or fact. This granularity makes linking precise and retrieval reliable.
Maps of Content (MOCs)	Index notes that curate and organize links to related atomic notes, serving as navigable entry points into knowledge areas
Progressive Summarization	A layered highlighting approach: raw capture, bold key passages, highlight critical insights, then write your own summary
Connection Discovery	Algorithmic analysis of note content to surface non-obvious relationships between ideas across different knowledge areas
Evergreen Notes	Mature notes that represent your refined understanding of a concept, continuously updated as your thinking evolves

┌──────────────┐     ┌───────────────┐     ┌──────────────┐
│   Raw Input  │────▶│   Processing  │────▶│   Atomic     │
│   Capture    │     │   & Tagging   │     │   Notes      │
└──────────────┘     └───────────────┘     └──────┬───────┘
                                                   │
┌──────────────┐     ┌───────────────┐             │
│   Evergreen  │◀───│   Connection  │◀─────────────┘
│   Synthesis  │     │   Discovery   │
└──────────────┘     └───────────────┘

Workflow Examples

Scenario 1: Processing a Book's Highlights

Input:

I just finished reading "Thinking in Systems" by Donella Meadows. 
I have 45 highlights in Readwise. Process them into my knowledge 
base and connect them to existing notes.

Output: The agent imports 45 highlights, creates a literature note for the book with metadata (author, ISBN, date read), then extracts 12 atomic concept notes (e.g., "Feedback Loops," "Leverage Points," "System Boundaries"). Each atomic note includes the original highlight, your margin notes, and the agent's discovered links — for example, "Feedback Loops" links to your existing notes on "Agile Retrospectives" and "Habit Formation Cycles."

Scenario 2: Weekly Knowledge Review

Input:

Do my weekly review. What did I capture this week, what needs 
processing, and what connections should I explore?

Output: A structured review showing: 8 new fleeting notes captured (3 processed, 5 pending), 2 literature notes from articles read, 4 new connection suggestions between this week's notes and existing knowledge, 3 orphan notes from previous weeks still needing links, and 1 evergreen note suggested for update based on new contradicting information captured this week.

Scenario 3: Preparing Research for a Blog Post

Input:

I want to write a blog post about "why most code reviews are 
ineffective." Pull together everything relevant from my knowledge 
base.

Output: An assembled research brief containing 14 relevant notes from your vault spanning software engineering practices, psychology of feedback, and team dynamics. Organized into an outline: opening hook from a "Code Review Anti-patterns" note, supporting evidence from "Cognitive Load in Reviews" and "Feedback Psychology" notes, counterarguments from "Pair Programming vs. Reviews" notes, and conclusion themes from "Engineering Culture" notes. Includes citation links back to original sources.

Best Practices

1. Capture first, organize later — Never let the desire for perfect organization stop you from capturing an idea. Use fleeting notes liberally and trust the weekly review process to sort them into the right places.

2. Write notes in your own words — Direct quotes are useful as references, but your knowledge base becomes powerful when you rephrase concepts in your own language. This forces understanding and makes future retrieval more natural.

3. Link generously but meaningfully — Every link should represent a genuine intellectual connection, not just topical similarity. Ask "how does this idea inform, contradict, or extend that one?" before creating a link.

4. Review connections, not just notes — During weekly reviews, spend time exploring the suggested connections. The most valuable insights often emerge from unexpected links between different knowledge areas.

5. Prune regularly — A knowledge base that only grows becomes unwieldy. Archive notes that no longer reflect your current thinking, merge duplicates, and remove links that no longer make sense as your understanding evolves.

Common Issues

Auto-linking suggests too many irrelevant connections

Increase the link_threshold from the default 0.7 to 0.85 or higher. This makes the similarity requirement stricter, surfacing only strong connections. You can also exclude certain knowledge areas from cross-linking if they produce noise (e.g., daily journal entries matching with technical notes on common words).

Obsidian vault becomes slow with many notes

If your vault exceeds 5,000 notes, disable real-time auto-linking and switch to batch processing during weekly reviews. Also ensure the agent writes frontmatter as YAML rather than inline tags, as Dataview queries perform better with structured metadata. Consider splitting into multiple vaults if knowledge areas are truly independent.

Imported highlights lack context

Readwise highlights often lack the surrounding context that made them meaningful. Enable include_notes: true in the Readwise config to import your annotations alongside highlights. During processing, the agent prompts you to add a one-sentence "why this matters" note to each highlight before filing it.

Privacy & Data Handling

All knowledge base operations happen locally within your Obsidian vault or notes directory. The agent reads and writes markdown files on your filesystem and does not transmit note content to any external service. Readwise and Raindrop integrations use those platforms' official APIs with your authorization tokens, pulling data into your local system. No note content, connection graphs, or personal insights are sent to third-party analytics. Search indexing is performed locally. If using Notion as your platform, note that Notion stores data on their servers per their privacy policy — the agent interacts with Notion's API but does not add additional data transmission beyond what Notion itself requires.