# Local-First Notes with Bidirectional Links: Setup Guide and AI-Enhanced Practices

    This article explains why large note collections often go unused, then walks through a complete setup built on two principles: local-first storage and bidirectional links. It covers directory structure, naming conventions, YAML properties and templates, linking and tagging practices, fast retrieval with search and queries, daily notes and weekly review routines, multi-device sync options with security safeguards, and three levels of AI enhancement, from single-note processing to retrieval-augmented question answering and automated workflows. It also includes a four-week rollout plan and a table of common pitfalls to avoid.

    1. The Problem: You Have Plenty of Notes, So Why Can’t You Use Them?

    Most people switch note-taking apps more than once, and their read-later folders hold hundreds of links. Yet when it is time to write a proposal, prepare a status update, or review a topic, they often end up searching from scratch again. The root cause usually isn’t the tool — it’s the structure. The symptoms fall into three categories:

    • Tool dependency: assuming a new app will solve the problem. Software is just a container. What decides whether notes can be reused and accumulate over time is the structure of the content.
    • Save dependency: hoarding other people’s articles and tutorials verbatim, with little of your own processing or summarizing. Raw material that has not been processed is hard to search, hard to locate, and hard to move into a new context.
    • Silo dependency: notes that stand in isolation, with the same topic scattered across many places. Human memory excels at association; if your note system cannot carry that association, it is only serving as a fancier folder.

    You can judge whether a note system works along three dimensions:

    1. Retrievable — when you need a piece of information, can you find it within a few seconds?
    2. Connectable — can new material be attached easily to knowledge you already have?
    3. Output-ready — can existing material be recombined quickly into an article, a proposal, or a report?

    If most of your notes stay stuck in a “saving is learning” state, they have effectively degraded into digital clutter that needs periodic cleanup. Turning raw material into a structured note library is precisely the precondition for improving the efficiency of everything that comes afterward. This article takes “local-first + bidirectional linking” as its main thread: it lays out the full path from an empty vault to an advanced setup, and shows how to use AI to turn a static note library into a queryable, reusable knowledge asset.

    2.1 Local-First: Own Your Data

    Local-first means data is stored first and foremost as ordinary files on your own devices, rather than inside an online service you must log in to reach. It brings four advantages:

    • Portable: the content is plain text files, so you can copy the whole collection into a new environment at any time, without worrying about being locked into one product.
    • Versionable: plain text fits version control well. Every change is recorded, and accidental deletions can be rolled back.
    • Automatable: plain text is easy to process in batches with scripts, to search programmatically, and to hand to AI.
    • Privacy-controlled: sensitive content can stay local, and you decide which data is allowed to leave your device.

    The cost of local-first is that sync and backup become your responsibility, which Section 7 addresses in detail.

    A conventional folder is a strict tree, and a note can belong to only one directory. Real knowledge, however, relates to several topics at the same time. A note about caching strategy belongs to backend development, but it also relates to database optimization and distributed systems.

    Bidirectional links change this. When note A references note B, the system automatically creates a backlink in B that points to A. This produces three changes:

    • Writing is pressure-free: when you create a new note, you only need to link it to existing related notes — you don’t have to design a classification slot in advance.
    • Relationships are traceable: open any note and you can see “which notes reference me,” making a topic’s background and development obvious at a glance.
    • Knowledge emerges: after long-term accumulation, the link graph naturally reveals research threads and clusters of knowledge, which helps you find weak spots.

    2.3 The Layered Architecture

    Local-first handles keeping data safe, while bidirectional links handle keeping it connected. Combined, they form the following layers:

    Layer Responsibility Typical carriers
    Storage Keep data safe, readable, portable Local text files, directory structure, version control, backups
    Structure Define each note’s identity and location Naming conventions, YAML properties, templates
    Connection Establish semantic relationships between notes Bidirectional links, tags, related notes
    Retrieval Locate and filter on demand Quick switcher, full-text search, property queries
    Enhancement Periodic review and intelligent processing Daily notes, regular reviews, AI-assisted processing

    3. First Steps: Directory Layout, Naming, and Templates

    3.1 Organize Directories by Purpose, Not by Subject

    A widely adopted approach divides notes by purpose rather than by discipline. Four categories, plus an inbox, permanent notes, and system configuration, are enough to form a clear and stable skeleton:

    • Projects: items with a defined goal and deadline, such as “Q4 tech talk”.
    • Areas: aspects you are responsible for and maintain over the long term, such as “backend development” or “health”.
    • Resources: reference material on topics you are interested in, such as “distributed systems reading”.
    • Archive: content that is finished or no longer active.
    1. vault/
    2. ├── 00-inbox/ # Inbox: all new content lands here first
    3. ├── 01-projects/ # Projects: have deadlines
    4. ├── 02-areas/ # Areas: require ongoing maintenance
    5. ├── 03-resources/ # Resources: reference material by topic
    6. ├── 04-archive/ # Archive: finished or shelved
    7. ├── 10-notes/ # Permanent notes: atomic, linked to each other
    8. ├── 20-daily/ # Daily notes: organized by date
    9. ├── 90-templates/ # Templates
    10. ├── 91-meta/ # Index, dashboard, query definitions
    11. └── 99-assets/ # Attachments such as images

    The advantage of organizing by purpose is that filing something requires answering only one question: why would I open it? A single item can link to many topics but should be stored in exactly one place, which avoids duplicating the same content in several locations with divergent versions.

    Two further recommendations:

    • Keep the directory depth to three levels or fewer; deeply nested trees raise maintenance costs.
    • Use lowercase letters, digits, and hyphens in folder and file names. Avoid spaces and special characters to prevent encoding problems when syncing across systems.

    3.2 Naming Conventions

    The filename itself is an index, so it should be sortable, searchable, and recognizable:

    Note type Naming scheme Example
    Daily note Date 2026-09-18.md
    Permanent note date-topic-keyword 2026-09-18-cache-invalidation.md
    Literature note author-year-keyword kleppmann-2017-ddia-summary.md

    Names that start with a date sort chronologically by nature. Topic keywords work best in English or pinyin: they are easy to type across devices and easy to handle in scripts. For notes with long titles, set an alias so links read more naturally.

    3.3 Templates and Properties

    Starting from a template that fixes the basic structure substantially lowers the cost of writing. Most note-taking tools support properties defined in YAML at the top of the document — this block is called the frontmatter:

    1. ---
    2. title: Comparing Cache Invalidation Strategies
    3. type: permanent # permanent/literature/daily/project
    4. status: growing # seed/growing/evergreen/archived
    5. tags:
    6. - area/backend
    7. - topic/caching
    8. created: 2026-09-18
    9. updated: 2026-09-18
    10. source: "[[kleppmann-2017-ddia-summary]]"
    11. ---
    12. ## Core Claim
    13. ## Evidence and Details
    14. ## Connections to Existing Knowledge
    15. - Related: [[2026-09-10-database-index-basics]]
    16. - Open questions:
    17. ## Action Items
    18. - [ ]

    type records the kind of note, which makes filtering by type and applying different templates easy. status marks how mature the note is:

    • Seed: a freshly captured idea.
    • Growing: evidence and context are still being added.
    • Evergreen: refined repeatedly and stable enough to cite as knowledge.
    • Archived: no longer active for now.

    tags declare the topic, and source records the origin for later traceability.

    You can also create separate templates for daily notes, literature notes, and project notes, each injecting the matching properties:

    • The daily template fills in the current date automatically and lists “captured today”, “learned today”, and “planned for tomorrow”.
    • The literature template requires the author, publication year, and three core claims.
    • The project template records the goal, milestones, and related notes.

    Templates are not only about saving effort. More importantly, fixed fields ensure that every note carries structured information from the moment it is created — information you can search and that programs can read.

    In tools that support bidirectional links, you usually create a link by wrapping the note name in double brackets:

    1. Building on the covering-index explanation in [[2026-09-10-database-index-basics]],
    2. cache penetration can also be mitigated with the rate-limiting approach
    3. from [[2026-08-22-rate-limiting-strategies]].

    Beyond the basic form, a few variants are commonly useful:

    • [[Target Note|Display Text]]: customize the link text so the sentence reads naturally.
    • [[Target Note#Section Heading]]: link to a specific section, for fine-grained references.
    • [[#Section in This Note]]: link to a section inside the current note, which suits longer structured notes.

    These practices keep a knowledge network healthy:

    1. One note, one topic: make each permanent note explain a single concept, so other notes can reference it precisely.
    2. Rewrite in your own words: restate ideas in your own language instead of copying whole passages. That “translation” step is itself understanding and internalizing.
    3. Build links deliberately: for every new note, think about at least which existing notes it relates to, and add the bidirectional links.
    4. Review links periodically: from time to time, check the backlink list and merge scattered notes into more stable topic notes.

    4.2 Dividing the Work Between Tags and Properties

    Bidirectional links express semantic relationships — what kind of relationship two notes have. Tags and properties express classification dimensions — the angles from which a single note can be filtered. Their roles are distinct:

    • Tags suit topic markers that cut across directories. Keep them consistent with a “layer/subcategory” format, such as area/backend or topic/distributed-system. Layers should generally not exceed two, and the total number of tags should stay restrained; otherwise tags degrade into another kind of folder.
    • Properties suit structured fields such as type, status, creation date, and source, which make filtering and sorting by condition easy.

    The practical rule is “links first, tags as a supplement.” If one bidirectional link can express the relationship, don’t add an extra tag. Tags are an auxiliary index outside the network structure, not the primary organizing mechanism.

    5. Retrieval and Filtering: Getting to Knowledge on Demand

    5.1 Three Retrieval Entry Points

    • Quick switcher: a keyboard shortcut opens a file search box; typing part of a filename or alias jumps straight there. Best when you already know where the target is.
    • Full-text search: search keywords across all note bodies. Best when you only remember a fragment. Most tools let you scope the search, for example to a single folder or file type.
    • Property queries: some tools offer database-like query syntax that can filter, sort, and aggregate by property, which is ideal for dynamic views such as “open items” or “updated this week”.

    5.2 Use Queries Instead of Manual Curation

    For example, a SQL-like query (illustrative) can find permanent notes that nothing links to:

    1. -- Illustrative: find permanent notes with no backlinks
    2. SELECT file.name AS note
    3. FROM files AS file
    4. WHERE file.folder = "10-notes"
    5. AND length(file.inlinks) = 0
    6. ORDER BY file.mtime DESC;

    Query results can usually be embedded in a dashboard note and update automatically as notes change. That removes the burden of hand-maintained lists and also helps you regularly surface notes that have “never been connected,” so you can pull them into the network in time.

    6. Advanced Workflows: Daily Notes, Weekly Review, and Output

    6.1 Daily Notes: Capture and Tidy Up

    Create one daily note each day as that day’s entry point. During the day, jot down ideas, meeting points, and reading excerpts quickly, without worrying about format. Spend five to ten minutes in the evening tidying up:

    • Promote anything worth keeping long-term into a standalone permanent note.
    • Move action items into the corresponding project or area.
    • Archive or delete content you have finished processing.

    The inbox and the daily note share one core principle: capture first, organize later. The lighter the capture step, the more often you will actually record.

    6.2 Weekly Review: Keeping the System Healthy

    Set aside a fixed slot each week for a review:

    1. Clear the inbox so nothing is left over.
    2. Skim the week’s new permanent notes and add any missing bidirectional links.
    3. Check project status and move completed projects to the archive.
    4. Look at the link graph for themes that recurred this week, and decide whether one deserves an evergreen note.

    6.3 Regular Output: Testing Whether Knowledge Is Internalized

    A note system’s final value shows up in its output. Some approaches worth trying:

    • Feynman-style check: explain a concept to someone in three sentences without looking at your notes. Wherever you cannot explain it clearly is usually where your understanding has a gap.
    • Topic synthesis: pick a topic, pull supporting arguments from related notes, and reassemble them into a complete article.
    • Proposal reuse: when writing a technical design or a retrospective, cite relevant permanent notes directly as supporting material.

    Output in turn exposes the weak points in your note system: which notes are hollow, which links are never used, which topics are missing a key piece. That feedback loop is what keeps a note library evolving.

    7. Multi-Device Sync and Data Safety

    7.1 Common Sync Options

    Option Suited to Advantages Watch out for
    Cloud drive syncing a folder Multiple personal devices Simple to configure, no extra knowledge needed Conflicts may produce duplicate copies that need periodic cleanup
    Version control repository Technical users Complete, traceable history; rollback to any version Repository size grows quickly with many attachments
    Self-hosted sync software Privacy-conscious users Peer-to-peer sync, data can stay on your own devices At least two devices must be online to sync
    The note tool’s built-in sync service Cross-platform mobile use Tight integration, works out of the box Evaluate terms of service, encryption, and export capability

    Whichever option you pick, one bottom line applies: always keep a backup that is independent of the sync chain. The well-known “3-2-1” rule is worth following — keep at least three copies of the data, on two different media, with one stored offsite.

    7.2 Security Reminders

    If you self-host a sync service or open access ports on your own devices, pay close attention to the following:

    1. Never expose an admin interface directly to the public internet. If remote access is genuinely required, put it behind a virtual private network (VPN), or reach it through a reverse proxy with authentication.
    2. Set strong passwords on every service and enable transport encryption.
    3. Close unnecessary ports once syncing is done.

    Sync tools are designed on the assumption that they run inside a trusted network, and many default configurations do not include strict authentication. Exposed directly to the public internet, your notes and even your device files can be at risk. This is the easiest thing to overlook when setting up a vault, and also the thing that deserves attention first.

    8. AI Enhancement: From File Archive to Queryable Knowledge Base

    8.1 Precondition: Organize First, Then Automate

    AI will not turn disorganized information into something orderly; it only amplifies the value of structure that already exists. Ask questions of a chaotic pile of material and you tend to get vague, generic filler. On a library with consistent properties and clear links, AI can locate precisely and produce answers you can trace. So work in a “organize a round, process a round” rhythm:

    1. First complete the directory and linking work from Sections 3 and 4.
    2. Then clean up old notes in batches, add properties, and establish connections.
    3. Only then bring in AI for processing and question answering.

    8.2 Three Levels of AI Application

    Level 1: Processing a Single Note

    Hand a long article or a set of meeting minutes to a large language model and ask for structured output — for example, “extract three core claims, list the supporting source text for each, and suggest which existing notes they should link to.” The key requirement is verifiable sources; do not accept content invented out of thin air.

    Level 2: Retrieval-Augmented Question Answering Across Notes (RAG)

    The idea behind RAG (retrieval-augmented generation) is to first retrieve the fragments most relevant to the question from your library, then pass those fragments to the model as context for generating an answer. The model then answers from your own notes rather than generalized knowledge from its training data, and every conclusion can be traced back to a specific note.

    A simplified flow looks like this:

    1. # Illustrative code: local note library + vector retrieval + LLM question answering
    2. from rag_pipeline import (
    3. load_notes, # read text and properties
    4. split_chunks, # split by section
    5. embed, # generate vectors
    6. search, # vector search
    7. ask_llm, # call the large language model
    8. )
    9. notes = load_notes("vault/", exts=[".md"], skip_folders=["99-assets"])
    10. chunks = split_chunks(notes, by="heading") # split by heading to preserve context
    11. index = embed(chunks) # build the vector index
    12. question = "How do you handle cache invalidation in this project?"
    13. hits = search(index, question, top_k=5)
    14. context = "\n\n".join(
    15. f"[Source: {h.note_path}]\n{h.text}" for h in hits
    16. )
    17. answer = ask_llm(prompt_with_context, context, question)
    18. print(answer)

    A few points matter in practice:

    • Split by meaning: prefer splitting along heading levels rather than cutting mechanically at a fixed character count, which would break context.
    • Carry metadata along: retrieval results should include the source file and section, so citations are easy and verification is possible.
    • Use hybrid retrieval: combining keyword search with vector search and merging the results is usually more stable than either alone. Vector search handles semantically similar content; keyword search excels at locating exact terms, identifiers, and code.

    Level 3: Automated Workflows

    Going further, you can orchestrate the processing pipeline into scheduled or event-triggered automation:

    • Daily digest: summarize the day’s new daily notes and permanent notes on a schedule, and write the result into the dashboard.
    • Action item extraction: automatically identify action items in meeting notes and write them into project notes.
    • Link suggestions: scan new note content, recommend related existing notes, and create the links after human confirmation.

    When building such workflows, you can let the model decide whether to call a given tool and keep going based on the tool’s return value until the task is finished. One thing must stay clear, though: AI output is always a suggestion, not a conclusion, so every automated write needs a human review step.

    8.3 Treating AI as Something You Cultivate Over Time

    Like a note system, AI-assisted capability also has to be cultivated over the long term rather than configured once and forgotten. Five dimensions are worth considering:

    Dimension What it actually means Practical advice
    Leaderboards Average performance on general tasks Not the same as your own experience; build a small evaluation set from your own notes
    Prompts How you construct context and express intent State the role, task, constraints, and output format clearly, and include examples
    Agents and tool orchestration The model calling tools to complete multi-step tasks Grant minimum necessary tool permissions; key actions need human confirmation
    Reasoning effort How much reasoning capacity the model spends Depth trades off against cost and latency; choose by task complexity
    Quotas and billing Token usage determines cost Cap how much the retrieval layer returns; use smaller models for summarization tasks

    Put differently, rather than chasing the “strongest model,” it pays more to invest in organizing your own material, refining your prompts, and building reliable workflows. That is the core capability that compounds over time and moves with you.

    8.4 Privacy and Cost Control

    • Tiered handling: publicly available technical material can go to a cloud model; notes containing personal information or work confidential data should prefer a locally deployed model, or be redacted before processing.
    • Cost awareness: most note Q&A tasks are lightweight retrieval and summarization. Choose the model tier to fit the task and avoid using a sledgehammer to crack a nut.

    9. A Four-Week Rollout: From Zero to Usable

    Stage Timing Core tasks Done when
    Foundation Week 1 Choose a sync method, create directories, set up templates and naming conventions New notes can be created quickly and consistently
    Migrating existing notes Week 2 Import old notes in batches by importance, starting with the ones you use most Daily work no longer sends you back to the old tool
    Weaving the network Week 3 Add at least 10 new permanent notes per week, each with two or more bidirectional links The link graph shows clear topic clusters
    Intelligent enhancement Week 4 Build a RAG question-answering flow and set up a daily digest automation You can ask questions against your own notes and get answers with sources

    There is no need to do everything at once. Spend the first week getting the basic flow working, then adjust directories, properties, and templates as you go. That is usually easier to sustain than designing a “perfect system” up front.

    10. Common Problems and How to Avoid Them

    Problem Symptom How to avoid it
    Tag explosion Tag count balloons and meanings overlap Cap the number of layers and total tags; periodically merge synonyms
    Excessive nesting Files nested five or six levels deep, hard to locate Keep directories within three levels; search instead of clicking down the tree
    Plugin dependency Heavy reliance on community plugins breaks after an upgrade Keep core plugins minimal, put configuration under version control, back up before upgrading
    Stray attachments Images and other attachments separated from notes, links break after migration Store everything in one attachment folder and use relative paths
    Island notes Many notes that nothing links to and nobody opens Clean up orphan notes monthly: archive them or add links
    Perfectionism Endless restructuring, no actual writing Write content first and optimize structure later; set a fixed review slot

    Conclusion

    A note system that actually works is essentially a personal knowledge pipeline of “input → processing → connection → output.” Local-first keeps your data in your own hands, bidirectional links let scattered information grow into a knowledge network, properties and retrieval make knowledge searchable at any time, and AI takes on summarizing, question answering, and automation along that pipeline. Tools will keep changing and features will keep accumulating, but the principle “organize the structure first, then add intelligence” will not go out of date. Start today: pick a sync method, set up your directories, and write your first bidirectional link — your second brain is already running.