Logseq: Privacy-First Knowledge Base That Actually Works Offline

So what is Logseq

Logseq is a privacy-first knowledge management system (PKM) tool. It stores your notes as SQLite files locally, so you own your data. But unlike Obsidian's markdown files, it uses an outliner interface - everything is structured bullets.

The key features:

• Outliner interface: Bullet-point editing by default, everything is structured
• Graph view: Visualize connections between notes as nodes and edges
• Bidirectional linking: [[page links]] that work both ways automatically
• Block-based: Each bullet is a block that can be moved anywhere
• Databases: SQL databases within your notes for structured data
li>PDF annotation: Highlight and comment on PDFs within Logseq
• Offline-first: Works completely offline, sync is optional
• Cross-platform: Desktop (Mac/Windows/Linux), mobile, web
• Plugin ecosystem: Community plugins extend functionality

Why it's different from other PKM tools:

• Outliner vs document editor - forces structured thinking
• Built-in databases - not an afterthought or plugin
• Graph view - actually useful, not just eye candy
• SQLite storage - faster and more powerful than markdown files
• Blocks are content-addressable - can be referenced anywhere

It's like if Roam Research and Obsidian had a baby, but with better architecture and privacy.

Getting Logseq running

Desktop app

Download from the official website:

# Download from https://logseq.com
# Supports macOS, Windows, Linux

# Install and launch
# Creates local graph at:
# ~/Logseq/Desktop/ (macOS/Linux)
# C:\Users\\AppData\Logseq\ (Windows)

First run asks you to create a graph - that's your knowledge base. Everything lives in SQLite files in that directory.

Mobile apps

# iOS: App Store
# Android: Google Play or F-Droid (FOSS version)

# Sync with desktop app via:
# - Local network sync (same WiFi)
# - Cloud sync (end-to-end encrypted)
# - iCloud (experimental)

Self-hosting

Run your own sync server:

# Use Docker for self-hosted sync
docker run -d \
  --name logseq-server \
  -p 12315:12315 \
  -v logseq_data:/root/logseq/data \
  logseq/logseq

Desktop app is all you need for personal use. Self-hosting only makes sense for teams or specific privacy requirements.

Basic usage

Creating notes

Everything in Logseq starts with a bullet:

# Hit enter to create new bullet
* This is a note about PKM tools
**Logseq** is an outliner
* Each bullet is a block
* Press Tab to indent, Shift+Tab to unindent

Block types

Different types of content blocks:

/code        : Code block with syntax highlighting
/todolist   : Todo list with checkboxes
/list       : Bullet list
/ordered     : Numbered list
/h1-h6       : Headings
/quote       : Block quote
/page        : Create new page and link
/alias       : Create redirect/shortcut

Bidirectional linking

Create connections between notes:

# Type [[ to create link
[[Another Page]] shows up as blue link

# Click to navigate there
# Creates backlink automatically
# Both pages show relationship

Slash commands

Type commands to insert blocks:

# Just type these to create blocks:
/block       : Insert content block
/heading     : Create heading
/query       : Search your knowledge base
/keyword     : Add keywords/tags
/pdf         : Import PDF file
/graph       : Open graph view

Properties and metadata

Add structured data to blocks:

# Right-click block → Properties
# Add custom properties:
- Status (select: Todo, Doing, Done)
- Priority (select: High, Medium, Low)
- Due Date (date picker)
- Tags (multi-select)
- Your custom fields

The graph view is actually useful

Most PKM tools have graph views but they feel gimmicky. Logseq's graph is genuinely useful.

Open it with /graph - see your entire knowledge base as a network. Notes are nodes, links are edges. Zoom in, explore connections you forgot about.

# What the graph shows:
- Nodes: Every bullet/block
- Edges: Links between blocks
- Colors: Based on tags, file types, or properties
- Size: Based on number of connections
- Filters: Show only specific tags or dates

# Practical uses I found:
- Discover related ideas I hadn't connected
- Find orphan notes that aren't linked to anything
- See clusters of related topics
- Visualize research threads over time

Linked references

See what links to the current page:

# Sidebar → "Linked References"
# Shows all pages that link here
- Backlinks from text references
- Database relations
- Manual links

# Great for:
- Finding orphan content
- Seeing how ideas connect
- Building knowledge graphs

Databases in Logseq

Creating a database

SQL database embedded in your notes:

# /database command
# Name your database: "Books to Read"

# Add properties:
- Title (title property, default text)
- Author (text)
- Rating (number 1-5)
- Status (select: Want to Read, Reading, Completed)
- Tags (multi-select)
- Date Added (date)
- Notes (text)

Creating database entries

Quick-add from anywhere:

# Type [[Database Name]] to create entry
[[Books to Read]]
# Cursor appears, you can fill fields
# Hit enter to save

# Or right-click block → Create database entry

Database views

View your data in different ways:

# Table view: Sort, filter, search
# Card view: Visual cards with custom properties
- Great for books, tasks, people

# Built-in queries:
- Show all items with property X
- Show items created in last N days
- Show items with tag Y

Advanced database features

Logseq has SQL built in:

# /query command opens SQL query box

# Example queries:
# Show all books by rating
SELECT * FROM 'Books to Read'
WHERE rating >= 4
ORDER BY rating DESC

# Show incomplete tasks
SELECT * FROM Tasks
WHERE status != 'Done'
ORDER BY due_date

# Results appear as table view
# Click to jump to source block

Setting up sync

Local network sync

Fast sync over WiFi - no internet needed:

# Desktop app Settings → Sync
# Enable "Local network sync"
# Both devices on same WiFi
# They find each other automatically
# End-to-end encrypted

# Pros:
# - Fast (local WiFi)
# - No internet needed
# - Free and unlimited
# - Privacy-focused (E2E encrypted)

# Cons:
# - Devices must be on same network
# - No access when apart

Cloud sync

Encrypted sync through official servers:

# Create account at https://sync.logseq.io
# Login from desktop app
# Enable cloud sync
# Data is encrypted before sending
# Decrypts on your devices

# Pricing:
# - Free tier: Limited sync (check current pricing)
# - Paid tier: Unlimited sync

# Pros:
# - Works from anywhere
# - Automatic backup
# - Multiple devices

# Cons:
# - Requires internet
# - Monthly cost for premium
# - Trust in their servers

Self-hosted sync

Run your own sync server:

# Host your own sync server
# Full control over data
# Can be self-hosted for free
# More complex setup

# Good for:
# - Teams wanting full control
# - Privacy-critical data
# - Avoiding third-party services

Sync conflict resolution

When both devices edited same content:

# Logseq shows conflict
# Compare both versions side-by-side
# Choose which to keep, or merge
# Handles nested blocks intelligently

# Rare for me (mostly use one main device)
# When it happens, resolution is straightforward

What I use Logseq for

Research notes

All my research, organized by project:

# Research graph databases:
- Machine Learning Research
- Web Dev Resources
- API Documentation
- Architecture Patterns

# Properties:
- Status (Reading, Tested, Implemented)
- Relevance (High, Medium, Low)
- Date Added
- Tags (#ml, #frontend, #backend)
- Notes (what I learned)

# Graph view shows connections between resources
- Find related research I'd forgotten
- See how ideas evolved over time

Task management

Daily tasks and project tracking:

# Tasks database
* [ ] Write documentation [[Project X]]
* [x] Review pull requests
* [ ] Update dependencies
* [ ] Plan sprint

# Nested bullets for subtasks
* [ ] Epic feature
    * [ ] Backend API
    * [ ] Frontend UI
    * [ ] Tests

# Properties:
- Priority, Assignee, Due Date
- Tags (bug, feature, chore)
- Links to related docs

# Can create database view for Kanban board
# Drag between columns

Reading list

Books to read, articles to review:

# Books database
* Designing Data-Intensive Applications
  * Author: @Martin Kleppmann
  * Rating: ⭐⭐⭐⭐⭐
  * Status: Completed
* [[The Pragmatic Programmer]]

# Properties:
- Author
- Category (Technical, Fiction, Biography)
- Status (Want to Read, Reading, Completed)
- Rating (1-5)
- Date Finished
- Notes (my takeaways)

# Can filter by:
- Category
- Status
- Rating
- Author

Zettelkasten

Atomic notes with permanent identifiers:

# Each note gets unique ID
# Based on content and timestamp
# Never changes, always accessible

# Create atomic notes:
- One idea per note
- Link related notes with [[ ]]
- Build knowledge graph over time

# Graph view shows emergent connections
# Discover relationships I hadn't noticed
# See clusters of related ideas

Meeting notes

Structured meeting notes with action items:

* Meeting with [[Design Team]] - 2026-03-09

* Attendees: @alice, @bob, @charlie
**Agenda**: Review Q1 roadmap

* [ ] Review Q1 deliverables
* [ ] Discuss Q2 priorities
* [ ] Resource planning

* Outcomes:
**[[Project X]] delayed by 2 weeks**
**Budget approved** for new initiative
* Action items:
    - @alice to update timeline
    - @bob to prepare budget breakdown
    - @charlie to communicate changes

# Properties:
- Type: Weekly team sync
- Tags: #design, #planning
- Related projects: [[Project X]], [[Budget 2026]]

Code snippets

Store code snippets with syntax highlighting:

/python
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]
    less = [x for x in arr[1:] if x < pivot]
    greater = [x for x in arr[1:] if x >= pivot]
    return quicksort(less) + [pivot] + quicksort(greater)

# Usage note: Use for educational purposes only
# Production code: Use built-in sort()
# From: [[Algorithms Book]]
# Tags: #python, #sorting

Advanced features

PDF annotation

Highlight and comment on PDFs:

# Upload PDF to Logseq
# Opens in sidebar
# Highlight text
# Add comments and notes
# Create pages from highlights

# Use cases:
- Research papers (highlight key findings)
- Technical docs (note important sections)
- Meeting notes (share annotated docs)

Plugins

Extend Logseq with community plugins:

# Install plugins from marketplace
# Settings → Plugins → Marketplace

# Popular plugins:
- Calendar integration
- GitHub sync
- Jira integration
- Zotero citations
- Backup tools
- Custom themes

# Or write your own plugins
# JavaScript and Clojure supported

Custom queries

Advanced search with SQL:

# /query → Advanced query

# Complex example:
SELECT blocks.*
FROM blocks
WHERE blocks.content LIKE '%machine learning%'
  AND blocks.properties->>'type' = 'article'
ORDER BY blocks.created_at DESC
LIMIT 50

# Results as block references
# Click to jump to source
# Shows context and connections

Journals and dailies

Daily notes with automatic date pages:

# Journal pages are auto-created
# Type /journal or /daily
# Creates page for today's date
# Great for daily standup notes

# Use with templates:
- Morning routine
- Evening reflection
- Daily goals
- Habit tracking

Flashcards

Built-in spaced repetition:

• Create cards from blocks
• Set interval (days, weeks, months)
• Review cards on schedule
• Track your retention

Logseq vs alternatives

Logseq is the sweet spot if you like structured thinking and graph visualization. Obsidian is simpler but less structured. Roam is powerful but expensive and cloud-only.

Would I recommend it?

Definitely. Switched from Obsidian to Logseq 8 months ago. Haven't looked back. The outliner interface forces structured thinking in a way that markdown files don't.

Graph view changed how I work. Instead of searching through text files, I explore my knowledge graph visually. Often discover connections I'd forgotten about.

Built-in databases are actually useful, not tacked on. I track books, tasks, research, meetings - all with proper queries and filtering.

Privacy-first design matters. My entire second brain lives on my machines. Sync is encrypted. I control my data completely.

Learning curve is real - outliner thinking takes practice. But once it clicks, it's powerful for structured thinking.

If you're building a personal knowledge base and care about privacy, graph visualization, or structured notes - Logseq is the best tool I've found.

Links: logseq.com | GitHub: github.com/logseq/logseq | Docs: docs.logseq.com