Most note-taking apps want you to pay monthly, sync through their cloud, or install an Electron app that eats 500MB of RAM. Memos takes a different approach: it’s a single binary that stores everything in SQLite, looks like a Twitter feed for your thoughts, and exposes a full API for automation.

What is Memos?

Memos is a self-hosted, open-source note-taking service built with Go and React. Think of it as a private micro-blog for quick thoughts, bookmarks, code snippets, and daily notes. Everything is stored locally, rendered in Markdown, and accessible through a clean web UI or REST API.

Why Self-Host Memos?

  • Lightweight: Single binary, SQLite database, minimal resource usage
  • Markdown support: Full Markdown rendering with code highlighting
  • REST API: Automate note creation from scripts, bots, or workflows
  • Tags and filters: Organize with #tags and powerful search
  • Timeline view: Scroll through notes like a personal Twitter feed
  • Multi-user: Share your instance with family or teammates
  • Media uploads: Attach images and files directly to notes
  • No vendor lock-in: Export everything, own your data

Prerequisites

Before starting, you’ll need:

  • A Linux server (Ubuntu 22.04+ or Debian 12+ recommended)
  • Docker and Docker Compose installed
  • A domain name pointed at your server (optional but recommended)
  • A reverse proxy like Nginx Proxy Manager, Traefik, or Caddy
  • Less than 256MB RAM (Memos is incredibly light)

Step 1: Create the Project Directory

mkdir -p ~/memos && cd ~/memos

Create a directory to keep your configuration and data organized.

Step 2: Create the Docker Compose File

nano docker-compose.yml

Paste the following configuration:

version: "3"
services:
  memos:
    image: neosmemo/memos:stable
    container_name: memos
    ports:
      - "5230:5230"
    volumes:
      - ./data:/var/opt/memos
    restart: unless-stopped

That’s it. No database containers, no Redis, no environment variables you need to configure. Memos uses an embedded SQLite database stored in the data directory.

Step 3: Start Memos

docker compose up -d

Memos will pull the image and start on port 5230. First launch takes about 10 seconds.

Step 4: Initial Setup

Open your browser and navigate to http://your-server-ip:5230. You’ll see the registration page.

  1. Create your admin account with a username and password
  2. That’s it — you’re in

The first user to register becomes the admin. If you want to prevent others from signing up, go to Settings → System → Disable Public Signup after creating your account.

If you’re running Nginx Proxy Manager, add a new proxy host:

  • Domain: memos.yourdomain.com
  • Forward Hostname/IP: your-server-ip
  • Forward Port: 5230
  • Enable SSL with Let’s Encrypt

For Caddy, add this to your Caddyfile:

m}emosr.eyvoeurrsdeo_mparionx.ycolmoc{alhost:5230

For Traefik users, add labels to your Docker Compose:

services:
  memos:
    image: neosmemo/memos:stable
    container_name: memos
    volumes:
      - ./data:/var/opt/memos
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.memos.rule=Host(`memos.yourdomain.com`)"
      - "traefik.http.routers.memos.entrypoints=websecure"
      - "traefik.http.routers.memos.tls.certresolver=letsencrypt"
      - "traefik.http.services.memos.loadbalancer.server.port=5230"
    restart: unless-stopped

Step 6: Using the API

One of Memos’ best features is its REST API. You can create notes programmatically — perfect for logging, automation, or building integrations.

Generate an API Token

Go to Settings → API → Create Token. Copy the token — you’ll need it for API calls.

Create a Memo via API

curl -X POST https://memos.yourdomain.com/api/v1/memos \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Deployed new server config at 3:42 PM #devops #infrastructure"
  }'

List Recent Memos

curl https://memos.yourdomain.com/api/v1/memos \
  -H "Authorization: Bearer YOUR_API_TOKEN"

Practical Automation Ideas

  • Server alerts: Pipe monitoring alerts into Memos as a log
  • Daily journal: Cron job that creates a daily template memo
  • Bookmark saver: Browser extension or script that saves URLs with notes
  • Git commit log: Post-commit hook that logs deploys to Memos
  • CLI quick capture: Shell alias to jot down thoughts from terminal

Here’s a quick shell alias for capturing thoughts:

# Add to ~/.bashrc or ~/.zshrc
memo() {
  curl -s -X POST https://memos.yourdomain.com/api/v1/memos \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d "{\"content\": \"$*\"}" > /dev/null && echo "✓ Saved"
}

# Usage: memo Just had a great idea for the API redesign #ideas

Step 7: Backup Your Data

Memos stores everything in SQLite, so backups are simple:

# Stop the container first for a clean backup
docker compose stop
cp -r ./data ./data-backup-$(date +%Y%m%d)
docker compose start

Or for a live backup without downtime:

sqlite3 ./data/memos_prod.db ".backup './data-backup-$(date +%Y%m%d).db'"

Troubleshooting

Port 5230 Already in Use

Change the port mapping in your Docker Compose file:

ports:
  - "5231:5230"

Can’t Upload Large Files

Memos has a default upload limit. If you’re behind a reverse proxy, make sure your proxy allows large uploads too. For Nginx:

client_max_body_size 50M;

Database Locked Errors

This usually happens when multiple processes access SQLite simultaneously. Make sure only one Memos container is running:

docker ps | grep memos

Lost Admin Access

If you can’t log in, you can reset via the container:

docker exec -it memos /bin/sh

Then check the SQLite database directly to reset your password.

Resource Usage

Memos is remarkably efficient:

  • RAM: ~30-50MB idle
  • CPU: Negligible
  • Disk: SQLite database grows slowly — thousands of notes barely touch 10MB
  • Startup: Under 3 seconds

This makes it perfect for low-power devices like a Raspberry Pi or a cheap VPS.

Wrapping Up

Memos hits a sweet spot that most note-taking apps miss: it’s fast enough for quick thoughts, structured enough for organization with tags and search, and extensible enough for automation through its API. The single-container, SQLite-backed architecture means there’s almost nothing to maintain.

If you’ve been looking for a private, lightweight place to dump thoughts, bookmarks, code snippets, and daily logs — Memos is hard to beat. Deploy it in 2 minutes, start writing, and let the API handle the rest.

Useful links: