# Ultra-Low Effort Obsidian Workflow for Academic Philosophers ## 1. Automated Note Creation and Organization ### Purpose - Minimize manual note creation and organization - Ensure consistent note structure without active effort - Automatically capture and categorize information ### Implementation #### 1.1 Templater Plugin for Dynamic Note Creation - Install the Templater plugin for advanced templating capabilities - Create dynamic templates that auto-populate with contextual information ##### [[Daily Note]] Template with Automated Sections ```markdown <%* const today = moment().format('YYYY-MM-DD'); const yesterday = moment().subtract(1, 'days').format('YYYY-MM-DD'); -%> # {{date:YYYY-MM-DD}} ## Automated Daily Summary <%* const dailySummary = await tp.system.prompt("Enter a brief summary of your day (or press enter to skip):"); -%> <% dailySummary %> ## Unprocessed Notes from Yesterday <%* const yesterdayNotes = tp.file.search("path:\"Daily Notes\" and file:" + yesterday) -%> <% yesterdayNotes.filter(note => !note.contains("#processed")).map(note => "- " + note.basename + "").join("\n") %> ## Upcoming Deadlines <%* const deadlines = tp.file.search("deadline") -%> <% deadlines.filter(note => moment(note.deadline).isAfter(today) && moment(note.deadline).isBefore(moment().add(7, 'days'))).map(note => "- [ ] " + note.basename + " (Due: " + note.deadline + ")").join("\n") %> ## Quick Captures - ## Auto-Tagged Notes <%* const tags = ["#philosophy", "#ethics", "#metaphysics", "#epistemology", "#logic"]; -%> <%* const taggedNotes = tags.map(tag => ({ tag, notes: tp.file.search(tag + " -path:\"Daily Notes\"") })); -%> <% taggedNotes.map(item => "### " + item.tag + "\n" + item.notes.slice(0, 5).map(note => "- " + note.basename + "").join("\n")).join("\n\n") %> ## Dataview: Recent Literature Notes ```dataview TABLE file.cday as "Created", file.tags as "Tags" FROM "Literature Notes" SORT file.cday DESC LIMIT 5 ``` ## Dataview: Unlinked Mentions ```dataview LIST FROM "Concept Notes" WHERE length(file.outlinks) = 0 LIMIT 10 ``` ``` #### 1.2 Zotero Integration for Automatic Literature Notes - Install the Zotero integration plugin - Set up automatic creation of literature notes from Zotero entries ##### Zotero-Generated Literature Note Template ```markdown --- title: {{title}} authors: {{authors}} year: {{year}} citekey: {{citekey}} doi: {{doi}} tags: {{tags}} --- # {{title}} ## Metadata - **Authors:** {{authors}} - **Year:** {{year}} - **Journal:** {{publicationTitle}} - **DOI:** {{doi}} - **Zotero Link:** {{pdfZoteroLink}} ## Abstract {{abstract}} ## Notes <%* const notes = await tp.system.prompt("Enter your notes (or press enter to skip):"); -%> <% notes %> ## Auto-Generated Summary <%* const summary = await tp.system.shellScript(`python summarize_text.py "${abstract}"`); -%> <% summary %> ## Relevant Quotes <%* const quotes = await tp.system.prompt("Enter relevant quotes (or press enter to skip):"); -%> <% quotes %> ## Auto-Suggested Links <%* const suggestedLinks = await tp.system.shellScript(`python suggest_links.py "${title}" "${abstract}"`); -%> <% suggestedLinks.split('\n').map(link => `- ${link}`).join('\n') %> ## Dataview: Related Notes ```dataview LIST FROM "Concept Notes" OR "Literature Notes" WHERE contains(file.outlinks, this.file.link) OR contains(file.inlinks, this.file.link) LIMIT 5 ``` ``` ### Usage Tips - Let the Daily Note template run automatically at the start of each day - Use the Zotero plugin to create literature notes directly from your reference manager - Review auto-generated summaries and suggested links for accuracy ## 2. Voice-to-Text and AI-Assisted Note-Taking ### Purpose - Enable hands-free note capture - Reduce the effort required to create and organize notes - Leverage AI for initial note processing and organization ### Implementation #### 2.1 Voice Notes Plugin - Install the Voice Notes plugin for Obsidian - Set up keyboard shortcuts or mobile widgets for quick voice note capture ##### Voice Note Template ```markdown --- date: {{date}} type: voice-note --- # Voice Note: {{date:YYYY-MM-DD HH:mm}} ## Transcription {{transcription}} ## Auto-Generated Summary <%* const summary = await tp.system.shellScript(`python summarize_text.py "${transcription}"`); -%> <% summary %> ## Auto-Extracted Concepts <%* const concepts = await tp.system.shellScript(`python extract_concepts.py "${transcription}"`); -%> <% concepts.split('\n').map(concept => `- ${concept}`).join('\n') %> ## Suggested Actions <%* const actions = await tp.system.shellScript(`python suggest_actions.py "${transcription}"`); -%> <% actions.split('\n').map(action => `- [ ] ${action}`).join('\n') %> ``` #### 2.2 GPT-3 Integration for Note Enhancement - Use the GPT-3 API to process and enhance notes - Create a custom script to send note content to GPT-3 and receive structured output ##### GPT-3 Enhanced Note Template ```markdown --- date: {{date}} type: gpt3-enhanced original_note: {{title}} --- # GPT-3 Enhanced Note: {{title}} ## Original Content {{content}} ## Enhanced Structure <%* const enhancedStructure = await tp.system.shellScript(`python gpt3_enhance.py "${content}"`); -%> <% enhancedStructure %> ## Suggested Connections <%* const connections = await tp.system.shellScript(`python gpt3_suggest_connections.py "${content}"`); -%> <% connections.split('\n').map(connection => `- ${connection}`).join('\n') %> ## Research Questions <%* const questions = await tp.system.shellScript(`python gpt3_generate_questions.py "${content}"`); -%> <% questions.split('\n').map(question => `- ${question}`).join('\n') %> ``` ### Usage Tips - Use voice notes for quick idea capture during research or while reading - Run the GPT-3 enhancement script on complex or unclear notes - Review AI-generated content for accuracy and relevance ## 3. Minimal-Effort Tagging and Linking ### Purpose - Reduce cognitive load associated with manual tagging and linking - Ensure consistent use of tags and links across notes - Improve note discoverability without active management ### Implementation #### 3.1 Automatic Tag Suggestion - Create a custom script that suggests tags based on note content - Integrate the script with the Templater plugin for automatic tag insertion ##### Auto-Tagging Script (Python) ```python import spacy from collections import Counter nlp = spacy.load("en_core_web_sm") def suggest_tags(text, n=5): doc = nlp(text) nouns = [token.text.lower() for token in doc if token.pos_ == "NOUN"] return [tag for tag, _ in Counter(nouns).most_common(n)] # Usage in Templater # <%* const suggestedTags = await tp.system.shellScript(`python suggest_tags.py "${content}"`); -%> # <% suggestedTags.split('\n').map(tag => `#${tag}`).join(' ') %> ``` #### 3.2 Fuzzy Linking with Unlinked Mentions Plugin - Install the Unlinked Mentions plugin - Configure it to automatically suggest links based on content similarity ##### Unlinked Mentions Configuration ```json { "minimum_match_length": 4, "excluded_folders": ["Daily Notes", "Templates"], "excluded_files": ["index.md"], "fuzzy_ratio": 0.8, "max_suggestions": 5 } ``` #### 3.3 Dataview for Automatic Link Discovery - Use Dataview queries to discover potential links between notes - Create a "Link Suggestions" note that updates automatically ##### Link Suggestions Note ```markdown # Link Suggestions ## Concept Notes without Links ```dataview TABLE file.outlinks as "Outgoing Links" FROM "Concept Notes" WHERE length(file.outlinks) = 0 ``` ## Notes with Similar Tags ```dataview TABLE rows.file.link AS "Similar Notes", rows.file.tags AS "Tags" FROM "Concept Notes" OR "Literature Notes" GROUP BY tags WHERE length(tags) > 0 FLATTEN tags GROUP BY tags WHERE length(rows) > 1 ``` ## Potential Connections by Content Similarity <%* const similarityMap = await tp.system.shellScript(`python find_similar_notes.py`); -%> <% similarityMap %> ``` ### Usage Tips - Review and approve auto-suggested tags and links periodically - Use the Link Suggestions note to quickly identify areas for connection - Let the Unlinked Mentions plugin guide you to potential connections as you write ## 4. Time-Based Note Management ### Purpose - Automatically resurface relevant old notes - Archive less relevant information without manual intervention - Encourage periodic review and refinement of your note system ### Implementation #### 4.1 Spaced Repetition with Review Plugin - Install the Review plugin for Obsidian - Set up automatic scheduling of note reviews ##### Review Plugin Configuration ```json { "defaultReviewDate": "next monday", "maxNoteAge": 90, "minNoteAge": 3, "extraTags": ["#to-review", "#important"], "reviewDateField": "review", "todoTags": ["#todo", "#task"], "scheduleTags": ["#schedule", "#project"] } ``` #### 4.2 Automatic Note Archiving - Create a script to move old, unlinked notes to an archive folder - Schedule the script to run monthly using your system's task scheduler ##### Auto-Archive Script (Python) ```python import os import shutil from datetime import datetime, timedelta def archive_old_notes(vault_path, archive_folder, days_threshold=180): current_date = datetime.now() for root, dirs, files in os.walk(vault_path): for file in files: if file.endswith('.md'): file_path = os.path.join(root, file) file_age = current_date - datetime.fromtimestamp(os.path.getmtime(file_path)) if file_age > timedelta(days=days_threshold): # Check if the note has any links with open(file_path, 'r') as f: content = f.read() if '' not in content and '' not in content: archive_path = os.path.join(archive_folder, file) shutil.move(file_path, archive_path) print(f"Archived: {file}") # Usage: # archive_old_notes('/path/to/vault', '/path/to/vault/Archive') ``` #### 4.3 Periodic Note Resurfacing - Create a dataview query to resurface old notes based on relevance and age - Include this query in your Daily Note template ##### Note Resurfacing Query ```markdown ## Notes to Revisit ```dataview TABLE file.mtime as "Last Modified", file.outlinks as "Outgoing Links", file.inlinks as "Incoming Links" FROM "Concept Notes" OR "Literature Notes" WHERE date(today) - file.mtime > dur(30 days) AND length(file.outlinks) + length(file.inlinks) > 3 SORT (length(file.outlinks) + length(file.inlinks)) DESC LIMIT 5 ``` ``` ### Usage Tips - Use the Review plugin to schedule important notes for future review - Let the auto-archive script run in the background to keep your vault tidy - Pay attention to resurfaced notes in your Daily Notes and consider updating them ## 5. Automated Academic Writing Support ### Purpose - Streamline the process of academic writing - Automatically aggregate relevant notes for article drafting - Generate preliminary outlines and literature reviews with minimal effort ### Implementation #### 5.1 Article Drafting Workspace - Create a template for article drafting that pulls in relevant notes - Use dataview to automatically populate sections with related content ##### Article Drafting Template ```markdown --- title: {{title}} status: draft related_concepts: {{related_concepts}} --- # {{title}} ## Automatic Outline <%* const outline = await tp.system.shellScript(`python generate_outline.py "${title}"`); -%> <% outline %> ## Relevant Concept Notes ```dataview LIST FROM "Concept Notes" WHERE contains(this.related_concepts, file.name) ``` ## Related Literature ```dataview TABLE authors as "Authors", year as "Year", file.tags as "Tags" FROM "Literature Notes" WHERE contains(file.outlinks, this.file.link) OR contains(file.tags, this.related_concepts) SORT year DESC ``` ## Preliminary Literature Review <%* const litReview = await tp.system.shellScript(`python generate_lit_review.py "${related_concepts}"`); -%> <% litReview %> ## Main Arguments 1. 2. 3. ## Potential Objections - ## Next Steps - [x] Refine outline ✅ 2024-09-19 - [x] Expand on main arguments ✅ 2024-09-19 - [x] Address potential objections ✅ 2024-09-19 - [x] Draft introduction ✅ 2024-09-19 - [x] Draft conclusion ✅ 2024-09-19 ``` #### 5.2 Automatic Citation Generation - Integrate with your reference management software (e.g., Zotero) - Use a script to generate citations and bibliographies automatically ##### Citation Generation Script (Python with pyzotero) ```python from pyzotero import zotero def generate_citations(library