Memos: The Complete Guide to Open-Source Fragmented Note-Taking

Ever had a brilliant idea at 2 AM, only to forget it by morning because opening your note-taking app felt like launching a spaceship? Memos strips note-taking down to its essence — fast capture, lightweight organization, and zero friction.

1. What Is Memos?

Memos is an open-source, lightweight note-taking service that combines the best of flomo and Twitter into a self-hosted micro-blogging-style note system. Its core value proposition is built on four pillars: fast capture, fragmented organization, self-hosted, and Markdown support.

Problems it solves:

• Traditional note-taking software is too heavy and slow to launch
• Ideas and thoughts are hard to capture quickly before they're lost
• Data stored on third-party cloud services raises privacy concerns
• Fragmented, scattered content is difficult to organize and retrieve

Ideal use cases:

• Personal inspiration and thought logging
• Study notes and knowledge management
• Daily work logs and journals
• Reading notes and highlights
• Idea and inspiration capture

---

2. Technical Architecture

Tech Stack:

• Backend: Go + Echo
• Frontend: React + TypeScript + Tailwind CSS
• Database: SQLite / MySQL / PostgreSQL
• Authentication: JWT
• API: RESTful + gRPC

Architecture highlights:
1. Single binary file, trivial to deploy
2. Built-in SQLite, no external database required
3. Responsive design with full mobile support
4. API-first design, easy to integrate

Core Modules:

┌──────────────────────────────────────┐

│         Memos Server          │

├──────────────────────────────────────┤

│  API 层  │  业务逻辑  │  存储层  │

├──────────────────────────────────────┤

│  用户  │  笔记  │  标签  │  资源  │

└──────────────────────────────────────┘

---

3. Core Features

3.1 Quick Capture

Input Methods

# Web interface

Type directly on the homepage
Multi-line text support
Real-time preview


Shortcuts


Ctrl/Cmd + Enter: Publish
Ctrl/Cmd + L: Toggle list/timeline view
Ctrl/Cmd + K: Quick search


Mobile


Bottom input bar
Voice input (browser-dependent)
Share menu integration

Content Format

# Supported formats

Markdown basic syntax
Code blocks (with syntax highlighting)
Lists (ordered/unordered)
Blockquotes
Links and images
Tags (#tag)
Todo items (- [ ] / - [x])


Example


Today I learned about Go's concurrency programming 🚀

go
go func() {
fmt.Println("Hello")
}()

#学习笔记 #Go #并发

3.2 Tag System

Tag Management

# Add tags

Use #tagname within your content


Tag hierarchy
Supports hierarchical tags like #work/projectA

Tag cloud
Automatically tracks tag usage frequency
Shows popular tags

Tag filtering
Click a tag to filter related notes
Supports multiple tag combination filtering

Tag Examples

# Project tags

#work/projectA

#work/projectB


Learning tags
#learning/Go
#learning/Python

Life tags
#life/reading
#life/exercise

3.3 Timeline View

View Modes

# Timeline view

Reverse chronological order
Infinite scroll loading
Grouped by date


List view


Card-style layout
Shows excerpts
Quick browsing


Calendar view


Monthly display
Marks dates with notes
Quick navigation

3.4 Search

Search Methods

# Full-text search

Searches both titles and content


Tag search
#tag searches for a specific tag

Date search
date:2024-01-01 searches for a specific date

Combined search
#Go date:2024-01 searches Go-related notes from January 2024

---

4. Deployment Guide

Option 1: Docker Deployment (Recommended)

1. Quick Start

# Create data directory

mkdir -p /opt/memos/data


Run container
docker run -d \
  --name memos \
  --restart=always \
  -p 5230:5230 \
  -v /opt/memos/data:/var/opt/memos \
  neosmemo/memos:latest

Access
http://localhost:5230

2. Docker Compose (Production)

# docker-compose.yml

version: "3.8"


services:

  memos:

    image: neosmemo/memos:latest

    container_name: memos

    restart: always

    ports:

      - "5230:5230"

    volumes:

      - ./data:/var/opt/memos

    environment:

      - MEMOS_MODE=prod

      - MEMOS_PORT=5230

      - MEMOS_DATA=/var/opt/memos

# Optional: Nginx reverse proxy

  nginx:

    image: nginx:alpine

    ports:

      - "443:443"

    volumes:

      - ./nginx.conf:/etc/nginx/nginx.conf:ro

      - ./ssl:/etc/nginx/ssl:ro

    depends_on:

      - memos

    restart: always

volumes:

  data:

3. Start Services

# Create directories

mkdir -p memos/{data,ssl}

cd memos


Create configuration file
vim docker-compose.yml

Start
docker-compose up -d

View logs
docker-compose logs -f memos

Access
http://localhost:5230

Option 2: Direct Installation

1. Download Binary

# Download latest release

wget https://github.com/usememos/memos/releases/latest/download/memos-linux-amd64.tar.gz


Extract
tar -xzf memos-linux-amd64.tar.gz

Move to bin
sudo mv memos /usr/local/bin/

Create data directory
sudo mkdir -p /var/opt/memos
sudo chmod 777 /var/opt/memos

2. Systemd Service

# Create service file

sudo vim /etc/systemd/system/memos.service


[Unit]

Description=Memos Service

After=network.target

[Service]

Type=simple

User=www-data

ExecStart=/usr/local/bin/memos --mode prod --port 5230 --data /var/opt/memos

Restart=always

RestartSec=10

[Install]

WantedBy=multi-user.target

Enable service
sudo systemctl daemon-reload
sudo systemctl enable memos
sudo systemctl start memos

Check status
sudo systemctl status memos

Option 3: Build from Source

1. Install Dependencies

# Install Go 1.21+

curl -fsSL https://go.dev/dl/go1.21.6.linux-amd64.tar.gz | sudo tar -C /usr/local -xzf -

export PATH=$PATH:/usr/local/go/bin


Install Node.js 18+
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install nodejs

Install pnpm
npm install -g pnpm

2. Build

# Clone the repository

git clone https://github.com/usememos/memos.git

cd memos


Build frontend
cd web
pnpm install
pnpm build

Build backend
cd ..
go build -o memos ./bin/memos

Run
./memos --mode prod --port 5230 --data ./data

---

5. Comparison with Alternatives

| Feature | Memos | Notion | Obsidian | flomo | Evernote |
|---------|-------|--------|----------|-------|----------|
| Open Source | Yes | No | No | No | No |
| Self-Hosted | Yes | No | Local only | No | No |
| Quick Capture | Yes (instant) | Slow (heavy app) | Medium | Yes (instant) | Slow |
| Markdown Support | Yes | Partial | Yes | Partial | Partial |
| Tag System | Yes (hierarchical) | Yes (database) | Yes | Yes (flat) | Yes |
| API Access | Yes (REST + gRPC) | Yes (limited) | Via plugins | Yes (limited) | Yes (limited) |
| Mobile Friendly | Yes (responsive) | Yes (app) | Via app | Yes (app) | Yes (app) |
| Cost | Free | Free tier, then paid | Free (sync paid) | Free tier, then paid | Free tier, then paid |
| Data Export | Markdown/JSON/HTML | Limited | Markdown | Limited | ENEX |
| Database | SQLite/MySQL/PostgreSQL | Cloud | Local files | Cloud | Cloud |

---

6. Common Issues & Troubleshooting

Issue 1: Sync Problems

# Troubleshooting steps

1. Check network connectivity

   ping memos-server

2. Check API health

   curl http://localhost:5230/api/v1/status

3. Verify access token

   Regenerate your Access Token in settings

4. Check permissions

   Ensure the token has write permissions

Issue 2: Data Loss

# Prevention measures

1. Regular backups

   Use the backup script provided below

2. Multi-location storage

   Back up to multiple locations

3. Version control

   Use Git to manage Markdown exports

Issue 3: Performance Degradation

# Optimization

1. Clean up old data

   Delete unnecessary notes and resources

2. Optimize queries

   Ensure database indexes are in place

3. Enable caching

   Set up Redis for session caching

4. Scale horizontally

   Use a load balancer for multiple instances

Issue 4: Cannot Upload Images

# Solutions

1. Check file permissions on the data directory

   sudo chown -R 1000:1000 /opt/memos/data

2. Verify disk space

   df -h /opt/memos/data

3. Check upload size limits

   If using Nginx, add: client_max_body_size 50M;

4. Review container logs

   docker logs memos

Issue 5: Forgot Admin Password

# Solutions

1. If you have CLI access, reset via the API:

   curl -X POST "http://localhost:5230/api/v1/auth/signin" \

     -H "Content-Type: application/json" \

     -d '{"username":"admin","password":"newpassword"}'

2. For Docker deployments, recreate the container with a fresh database:

   # WARNING: This will lose all data

   docker stop memos && docker rm memos

   # Re-run with a new data volume

3. For SQLite, directly modify the database:

   sqlite3 /opt/memos/data/memos_prod.db

   # Update the user table with a new password hash

---

7. FAQ

Q1: Is Memos suitable for long-form writing?
Memos is designed for quick, fragmented note-taking rather than long-form articles. While it supports full Markdown, its strength lies in capturing short ideas and thoughts quickly. For lengthy documents, consider pairing it with a tool like Obsidian or Notion.

Q2: Can I use Memos offline?
The web interface requires a server connection. However, you can export all notes as Markdown files for offline access. Some community-built mobile apps also offer offline caching with sync-on-reconnect functionality.

Q3: How do I migrate from flomo to Memos?
Memos supports JSON import. Export your flomo data as JSON, then use the Memos API to import your notes. There are also community migration scripts available on GitHub that automate this process.

Q4: Does Memos support multi-user?
Memos has basic multi-user support. You can create multiple user accounts, and each user has their own private workspace. However, it doesn't currently support collaborative editing or shared workspaces — it's primarily designed as a personal note-taking tool.

Q5: Can I integrate Memos with other tools?
Yes. Memos provides a full RESTful API that enables integration with virtually any tool. Popular integrations include Telegram bots (for capturing messages), Obsidian (for syncing notes), iOS Shortcuts, Android Tasker, and RSS readers.

Q6: What happens to my data if I stop using Memos?
Your data is always yours. You can export everything as Markdown, JSON, or HTML at any time via the web interface or API. Since Memos is self-hosted, your data never leaves your server unless you explicitly export it.

---

8. Who Should Use This?

Memos is ideal for:

• Anyone who wants to capture thoughts quickly without app friction
• Privacy-conscious users who want full control of their data
• Developers looking for an API-first note-taking service
• Teams that need a self-hosted micro-blogging knowledge base
• Students and researchers who accumulate fragmentary notes
• People who love Markdown and want a lightweight capture tool

Memos may not be ideal for:

• Users needing complex document formatting and long-form writing
• Teams requiring real-time collaborative editing
• Those who need powerful full-text search across large archives
• People who want a zero-maintenance cloud solution (no self-hosting)

---

Verdict

Memos is a lightweight, fast, and elegant fragmented note-taking tool. It solves the core problem of traditional note apps being too heavy and slow — with Memos, recording an idea is as simple as typing a tweet. The self-hosting capability, combined with a clean API and Markdown support, makes it a perfect choice for anyone who values speed, privacy, and simplicity.

For anyone who loves capturing ideas but hates the friction of traditional note apps, Memos will make you wonder why note-taking wasn't always this effortless.

GitHub Repository: https://github.com/usememos/memos