Obsidian
Collaboration Tool
Obsidian
Overview
Obsidian is a knowledge management tool based on local Markdown files featuring inter-note linking functionality and knowledge visualization through graph view. It specializes in privacy-focused personal knowledge base construction and serves as the first choice for personal knowledge management (PKM). It introduced Sync Standard Plan ($4/month) in 2024 and is popular among researchers, writers, and engineers. Supported by privacy-focused users, it provides a future-proof PKM system through rich community plugins and Markdown foundation.
Details
Obsidian 2025 edition has established its position as the premier tool in personal knowledge management (PKM). Through local-first design based on Markdown files, it achieves complete data control and high portability. Bidirectional linking, graph view, and networked thinking enable knowledge networking beyond traditional hierarchical note organization. It provides infinite extensibility through over 1,000 community plugins, custom themes, and CSS customization. It comprehensively supports research, writing, and learning workflows through canvas view, daily notes, Dataview plugin data analysis, and Zettelkasten method support. Through encrypted sync, publish features, and mobile apps, it covers everything from personal knowledge management to professional research activities.
Key Features
- Local Markdown Files: Complete data control and vendor lock-in avoidance
- Bidirectional Links and Graph View: Visual understanding of knowledge relationships
- Rich Plugin Ecosystem: Over 1,000 community plugins
- Canvas View: Visual thinking and idea mapping
- Encrypted Sync: Secure data synchronization with end-to-end encryption
- Complete Customizability: Free extension through CSS, themes, and plugins
Advantages and Disadvantages
Advantages
- Complete data ownership and privacy protection (local files)
- High portability and future-proofing through Markdown standard
- Infinite extensibility through rich plugin ecosystem
- Knowledge relationship visualization and discovery through graph view
- Intuitive linking functionality and backlink tracking
- Advanced customizability (CSS, themes, plugins)
- Optimization of research, writing, and learning workflows
- Long-term cost efficiency (basic features free)
Disadvantages
- Learning cost for initial setup and plugin selection
- Limited team collaboration features
- Mobile version functionality constraints (limited plugin support)
- Performance issues when processing large amounts of data
- Sync functionality requires paid plan (Sync)
- Technical knowledge required for advanced customization
- Limited web-based access
- May be too complex for beginners
Reference Links
- Obsidian Official Site
- Obsidian Help
- Obsidian Community
- Obsidian Hub
- Obsidian Plugin Directory
- Obsidian GitHub
Usage Examples
Basic Setup and Vault Creation
# Obsidian basic setup
# 1. Download from official site: https://obsidian.md/
# 2. Install (Windows/Mac/Linux support)
# 3. Create new Vault or open existing folder
# 4. Configure plugins and themes in settings
# Basic Vault structure example
Personal Knowledge Vault/
├── 00 - Index/
│ ├── Dashboard.md
│ ├── MOCs (Maps of Content)/
│ └── Templates/
├── 01 - Projects/
│ ├── Current Projects/
│ ├── Archive/
│ └── Ideas/
├── 02 - Areas/
│ ├── Health/
│ ├── Finance/
│ └── Career/
├── 03 - Resources/
│ ├── References/
│ ├── Learning/
│ └── Tools/
└── 04 - Archive/
├── Completed/
└── Deprecated/
# Recommended plugin configuration
Core Plugins:
- Daily Notes ✓
- Templates ✓
- Graph View ✓
- Backlinks ✓
- Tag Pane ✓
- File Explorer ✓
Community Plugins:
- Dataview ✓
- Calendar ✓
- Advanced Tables ✓
- Templater ✓
- QuickAdd ✓
Basic Note Creation and Linking Features
# Project Management Note Example
## Project: Web Reference Site Development
### Basic Information
- **Start Date**: [[2025-01-01]]
- **Deadline**: [[2025-03-31]]
- **Status**: #in-progress
- **Priority**: #high-priority
- **Assignee**: [[John Doe]]
### Related Notes
- [[Project Plan]]
- [[Tech Stack Selection]]
- [[Progress Report]]
- [[Issue Management]]
### Purpose
Build [[Web Reference]] site to provide collaboration tool information for developers.
### Tech Stack
- **Frontend**: [[TypeScript]] + [[React]]
- **Backend**: [[Node.js]] + [[Express]]
- **Database**: [[PostgreSQL]]
- **Deploy**: [[Vercel]]
### Task List
- [ ] Requirements definition complete [[2025-01-15]]
- [ ] UI/UX design [[2025-01-30]]
- [x] Technology selection [[2025-01-08]]
- [ ] Prototype development [[2025-02-15]]
### Lessons Learned
Through this project, I recognized the importance of [[Project Management]].
Particularly [[Stakeholder Management]] and [[Risk Management]] are keys to success.
### References
- [Technical Specifications](./specifications.pdf)
- [[Competitive Analysis]] - Similar site research results
- [[User Interview]] - Target audience research
---
## Daily Note Example (2025-01-08)
### Today's Plan
- [ ] [[Web Reference]] project: Tech selection meeting 10:00-11:00
- [ ] [[Obsidian]] plugin research and configuration
- [ ] [[Weekly Review]] preparation
### Learning Notes
#### [[TypeScript]] Study Memo
```typescript
// Generics usage example
interface Repository<T> {
find(id: string): Promise<T | null>
save(entity: T): Promise<T>
delete(id: string): Promise<void>
}
class UserRepository implements Repository<User> {
async find(id: string): Promise<User | null> {
// implementation
}
}
Today's Insights
[[Type Safety]] directly relates to development efficiency and quality improvement. Understanding [[Design Patterns]] affects implementation quality.
Reflection
- Good points: Achieved consensus on tech selection in team meeting
- Improvements: Should spend more time on preparation
- Tomorrow's challenges: [[Prototype]] development planning
Related Memos
- [[Team Communication]] improvement methods
- [[Technical Debt]] management strategy
MOC (Map of Content) Example
Programming Learning MOC
Overview
Map organizing all knowledge related to programming learning
Fundamentals
Programming Languages
- [[JavaScript]] - Foundation of web development
- [[TypeScript]] - Type-safe JavaScript
- [[Python]] - Data science and AI
- [[Go]] - Backend development
- [[Rust]] - Systems programming
Frameworks
- [[React]] - Frontend library
- [[Next.js]] - React framework
- [[Express]] - Node.js framework
- [[FastAPI]] - Python web framework
Development Practices
Design Patterns
- [[Singleton Pattern]]
- [[Observer Pattern]]
- [[Factory Pattern]]
- [[MVC Architecture]]
Testing Methods
- [[Unit Testing]] - Unit tests
- [[Integration Testing]] - Integration tests
- [[E2E Testing]] - End-to-end tests
- [[Test-Driven Development]]
Projects
Completed Projects
- [[Portfolio Website]] - Personal site development
- [[Task Manager App]] - Task management app
In Progress Projects
- [[Web Reference]] - Tech information site
- [[PKM System]] - Personal knowledge management system
Learning Resources
Books
- [[Clean Code]] - Robert C. Martin
- [[Design Patterns]] - GoF
- [[Effective TypeScript]] - Dan Vanderkam
Online Courses
- [[MDN Web Docs]] - Web technology reference
- [[TypeScript Handbook]] - Official documentation
Next Steps
- Learn [[Microservices]] architecture
- Practice [[Docker]] and [[Kubernetes]]
- Master [[AWS]] cloud services
Research Note Example
Zettelkasten Method for Knowledge Management
Idea Development
[[202501081030]] Connectivity of knowledge as source of innovation
↓
[[202501081045]] Knowledge network analysis using graph theory
↓
[[202501081100]] Potential of Obsidian graph view utilization
Hypothesis
Higher link density between knowledge pieces leads to more creative ideas.
Verification Method
- Quantitative analysis using [[Graph Metrics]]
- Recording [[Idea Generation Sessions]]
- [[Correlation Analysis]] for relationship investigation
References
- Luhmann, N. (1992). Communicating with Slip Boxes
- [[How to Take Smart Notes]] - Sönke Ahrens
- [[The Zettelkasten Method]] - Practice guide
Related Research
- [[Network Science]] - Network science
- [[Cognitive Load Theory]] - Cognitive load theory
- [[Knowledge Graphs]] - Knowledge graphs
Next Actions
- Detailed [[Experiment Design]]
- Finalize [[Data Collection]] methods
- Select [[Analysis Tools]]
### Plugin Usage and Automation
```javascript
// Dataview plugin usage examples
// Tasks due today
```dataview
TASK
FROM ""
WHERE completion = false AND due = date(today)
SORT priority DESC
// Progress by project
TABLE
status as "Status",
length(file.tasks.completed) as "Completed Tasks",
length(file.tasks) as "Total Tasks",
round((length(file.tasks.completed) / length(file.tasks)) * 100) + "%" as "Progress"
FROM "01 - Projects"
WHERE type = "project"
SORT file.name ASC
// Recently updated notes
LIST
FROM ""
WHERE file.mtime >= date(today) - dur(7 days)
SORT file.mtime DESC
LIMIT 10
// Note count by tag
TABLE length(rows) as "Note Count"
FROM ""
FLATTEN file.tags as tag
GROUP BY tag
SORT length(rows) DESC
// Monthly learning records
TABLE
length(rows) as "Learning Sessions",
sum(rows.duration) as "Total Learning Time"
FROM "03 - Resources/Learning"
WHERE type = "learning-session"
GROUP BY dateformat(date, "yyyy-MM") as "Month"
SORT "Month" DESC
### Template Automation with Templater Plugin
```javascript
// Templater template examples
// Daily review template
<%*
const today = tp.date.now("YYYY-MM-DD");
const yesterday = tp.date.now("YYYY-MM-DD", -1);
%>
# Daily Review - <% today %>
## Yesterday's Reflection
![[<% yesterday %>#Reflection]]
## Today's Plan
### Most Important Tasks (MIT)
1. [ ]
2. [ ]
3. [ ]
### Other Tasks
- [ ]
- [ ]
## Learning Goals
- [ ]
## Today's Insights & Learning
## Handover to Tomorrow
## Energy Level
Health: ⭐⭐⭐⭐⭐
Focus: ⭐⭐⭐⭐⭐
Motivation: ⭐⭐⭐⭐⭐
---
// Project template
<%*
const projectName = await tp.system.prompt("Enter project name:");
const startDate = tp.date.now("YYYY-MM-DD");
const category = await tp.system.suggester(
["Personal", "Work", "Learning", "Research"],
["personal", "work", "learning", "research"]
);
%>
# <% projectName %>
## Project Information
- **Category**: #<% category %>
- **Status**: #planning
- **Start Date**: <% startDate %>
- **Deadline**:
- **Priority**: #medium-priority
## Purpose & Background
## Success Criteria
## Required Resources
### Human Resources
-
### Technology & Tools
-
### References
-
## Milestones
- [ ] Phase 1:
- [ ] Phase 2:
- [ ] Phase 3:
## Risks & Countermeasures
## Progress Log
### <% tp.date.now("YYYY-MM-DD") %>
-
## Related Notes
-
---
// Weekly review template
<%*
const weekStart = tp.date.now("YYYY-MM-DD", 0, "dddd") === "Monday" ?
tp.date.now("YYYY-MM-DD") :
tp.date.now("YYYY-MM-DD", -7 + (1 - tp.date.now("d")));
const weekEnd = tp.date.weekday(weekStart, 6, "YYYY-MM-DD");
%>
# Weekly Review - <% weekStart %> to <% weekEnd %>
## Goal Achievement Status
### Main Goals
- [ ] Goal 1
- [ ] Goal 2
- [ ] Goal 3
### Learning Goals
- [ ]
## This Week's Highlights
### Achievements & Accomplishments
### What I Learned & Insights
### Challenges & Improvements
## Next Week's Plan
### Main Goals
1.
2.
3.
### Learning Plan
### Notes & Reminders
## Metrics
```dataview
TASK
FROM ""
WHERE completion = true AND completed >= date(<% weekStart %>) AND completed <= date(<% weekEnd %>)
Energy Management
- High Energy Time:
- Low Energy Time:
- Improvement Actions:
### Advanced Automation and Workflows
```bash
# Obsidian automation script examples
# 1. Automatic backup script (bash)
#!/bin/bash
# daily-backup.sh
VAULT_PATH="/path/to/your/obsidian/vault"
BACKUP_PATH="/path/to/backup/location"
DATE=$(date +%Y%m%d_%H%M%S)
# Create vault backup
tar -czf "${BACKUP_PATH}/obsidian_backup_${DATE}.tar.gz" -C "${VAULT_PATH}" .
# Remove backups older than 30 days
find "${BACKUP_PATH}" -name "obsidian_backup_*.tar.gz" -mtime +30 -delete
echo "Backup completed: obsidian_backup_${DATE}.tar.gz"
# 2. Graph metrics analysis script (Python)
import json
import os
import re
from collections import defaultdict
import networkx as nx
class ObsidianGraphAnalyzer:
def __init__(self, vault_path):
self.vault_path = vault_path
self.graph = nx.Graph()
self.notes = {}
def scan_vault(self):
"""Scan vault to extract notes and links"""
for root, dirs, files in os.walk(self.vault_path):
for file in files:
if file.endswith('.md'):
file_path = os.path.join(root, file)
self.process_note(file_path)
def process_note(self, file_path):
"""Process individual note to extract links"""
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
note_name = os.path.basename(file_path)[:-3] # Remove .md
self.notes[note_name] = {
'path': file_path,
'content': content,
'word_count': len(content.split()),
'links': []
}
# Extract [[link]] format links
links = re.findall(r'\[\[([^\]]+)\]\]', content)
for link in links:
clean_link = link.split('|')[0] # Remove alias
self.notes[note_name]['links'].append(clean_link)
self.graph.add_edge(note_name, clean_link)
def analyze_graph(self):
"""Analyze graph structure"""
analysis = {
'total_notes': len(self.notes),
'total_connections': self.graph.number_of_edges(),
'average_connections': self.graph.number_of_edges() * 2 / len(self.notes),
'most_connected_notes': [],
'isolated_notes': [],
'clusters': []
}
# Sort by connection count
degree_centrality = nx.degree_centrality(self.graph)
sorted_notes = sorted(degree_centrality.items(), key=lambda x: x[1], reverse=True)
analysis['most_connected_notes'] = sorted_notes[:10]
# Isolated notes
analysis['isolated_notes'] = [note for note, degree in self.graph.degree() if degree == 0]
# Cluster analysis
if self.graph.number_of_nodes() > 0:
communities = nx.community.greedy_modularity_communities(self.graph)
analysis['clusters'] = [list(community) for community in communities]
return analysis
def generate_report(self):
"""Generate analysis report"""
analysis = self.analyze_graph()
report = f"""# Obsidian Knowledge Graph Analysis Report
## Overview
- **Total Notes**: {analysis['total_notes']}
- **Total Connections**: {analysis['total_connections']}
- **Average Connections per Note**: {analysis['average_connections']:.2f}
## Most Connected Notes
"""
for note, centrality in analysis['most_connected_notes']:
connections = self.graph.degree(note)
report += f"- **{note}**: {connections} connections\n"
report += f"""
## Isolated Notes ({len(analysis['isolated_notes'])})
"""
for note in analysis['isolated_notes'][:10]: # Show first 10 only
report += f"- {note}\n"
report += f"""
## Knowledge Clusters ({len(analysis['clusters'])})
"""
for i, cluster in enumerate(analysis['clusters'][:5]): # First 5 clusters only
report += f"- **Cluster {i+1}**: {len(cluster)} notes\n"
for note in cluster[:3]: # First 3 notes per cluster only
report += f" - {note}\n"
# Save to report file
report_path = os.path.join(self.vault_path, "Graph_Analysis_Report.md")
with open(report_path, 'w', encoding='utf-8') as f:
f.write(report)
return report
# Usage example
analyzer = ObsidianGraphAnalyzer("/path/to/your/vault")
analyzer.scan_vault()
report = analyzer.generate_report()
print("Graph analysis completed. Report saved to vault.")
# 3. Auto-tagging script (Python)
import openai
import os
class ObsidianAutoTagger:
def __init__(self, vault_path, openai_api_key):
self.vault_path = vault_path
openai.api_key = openai_api_key
def suggest_tags(self, note_content, existing_tags):
"""Use AI to suggest tags"""
prompt = f"""
Analyze the following Obsidian note content and suggest 3-5 appropriate tags.
Existing tag list: {', '.join(existing_tags)}
Note content:
{note_content[:1000]}...
Suggested tags (comma-separated):
"""
try:
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}],
max_tokens=100
)
suggested_tags = response.choices[0].message.content.strip().split(', ')
return [tag.strip('#') for tag in suggested_tags]
except Exception as e:
print(f"API Error: {e}")
return []
def process_notes_without_tags(self):
"""Process notes without tags"""
existing_tags = set()
# Collect existing tags
for root, dirs, files in os.walk(self.vault_path):
for file in files:
if file.endswith('.md'):
file_path = os.path.join(root, file)
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# Extract existing tags
tags = re.findall(r'#(\w+)', content)
existing_tags.update(tags)
# Process notes without tags
for root, dirs, files in os.walk(self.vault_path):
for file in files:
if file.endswith('.md'):
file_path = os.path.join(root, file)
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read()
# Process only if few tags
current_tags = re.findall(r'#(\w+)', content)
if len(current_tags) < 2:
suggested_tags = self.suggest_tags(content, list(existing_tags))
print(f"File: {file}")
print(f"Suggested tags: {suggested_tags}")
print("---")
# Usage example
# auto_tagger = ObsidianAutoTagger("/path/to/vault", "your-openai-api-key")
# auto_tagger.process_notes_without_tags()