Memos: a self-hosted, Markdown-native capture tool you run yourself

What problem Memos solves, and who it is actually for

Memos targets a narrow slice of note-taking: the quick capture of a thought, a link, or a snippet, without opening a document editor or a folder tree. The README describes the interface as "timeline-first", meaning notes appear in reverse-chronological order rather than inside a hierarchical notebook. That is the whole design premise. If you have ever abandoned a notes app because filing a note took longer than writing it, this is the trade-off Memos makes on your behalf.

The audience the README addresses is self-hosters. Data stays on infrastructure you control, and the project states there is no telemetry. That matters for teams or individuals with data-residency constraints, or anyone who wants to stop paying a subscription for what amounts to a text box and a database. A single Go binary or one Docker container is the entire deployment surface.

It is not aimed at people who want a knowledge base with backlinks, a task manager, or a collaborative document suite. The feature list covers capture, self-hosting, deployment options and APIs. Nothing in the README promises real-time collaboration, versioned documents, or an offline-first mobile client. Read that list as the scope of the product.

How Memos is put together: one server, three storage options, two APIs

The repository layout shows a Go module at github.com/usememos/memos with separate top-level directories for cmd, core, internal, server, store, proto, markdown, provider and web. That split is informative. The web directory is the frontend, and the Go side is organized so that the storage layer sits in store, the HTTP and RPC surface sits in server, and shared behaviour sits in core. The presence of proto indicates the API is defined in Protocol Buffers, which is consistent with the README's claim of REST and gRPC APIs.

The dependency list confirms the mechanism rather than just the marketing. connectrpc.com/connect and grpc-gateway appear in go.mod, which is how a single protobuf definition can be served over both gRPC and REST. The markdown directory plus github.com/yuin/goldmark in go.mod explains the Markdown-native claim: notes are parsed and rendered with goldmark rather than stored as HTML. The store directory pairs with drivers for SQLite (modernc.org/sqlite), MySQL (go-sql-driver/mysql) and PostgreSQL (lib/pq), matching the three databases the README lists.

Data flow is therefore conventional and easy to reason about: a client writes a note through the API, the server persists it in the configured database, and the web frontend renders Markdown back to the reader. Because the API is first-class, the web UI is one client among possible others. The README points to a separate web-clipper extension for Chrome and Firefox that saves pages, selected text and images into your instance and lets you set visibility and Markdown format before saving.

Installing Memos with Docker and writing your first note

The README recommends Docker and gives a single command. It publishes the container on port 5230 and mounts a host directory at /var/opt/memos for persistence, so the notes survive a container restart. Run it, then open the printed URL in a browser.

docker run -d \
  --name memos \
  -p 5230:5230 \
  -v ~/.memos:/var/opt/memos \
  neosmemo/memos:stable

After the container starts, the README says to open http://localhost:5230 and start writing. The first screen is the timeline. Create an account in the running instance, then type a note into the composer and save it; it appears at the top of the timeline and is stored in the database file under the mounted volume.

If you prefer not to run Docker, the README offers a native install script. It notes that native macOS binaries require macOS 13 Ventura or later, which is a real constraint for older machines.

curl -fsSL https://raw.githubusercontent.com/usememos/memos/main/scripts/install.sh | sh

The README also lists Docker Compose as the recommended method for production, along with Kubernetes via Helm charts and manifests, and building from source for development. Detailed steps are deferred to the deployment guide at usememos.com/docs/deploy. For a first evaluation, the demo instance at demo.usememos.com is the fastest way to see the interface before installing anything.

Where Memos stops being the right tool

The timeline model is the main limitation, and it is deliberate. Notes are ordered by time, not by hierarchy. If your work involves long documents, nested folders, or cross-referencing between pages, the README offers no structure for that. Markdown rendering gives you formatting, but formatting is not organization.

Search and retrieval are not described in the README at all. The feature list covers capture, ownership, deployment and integration. There is no claim about full-text search, tags, or filtering. You should not assume these exist; verify them in the running instance before you migrate years of notes into it.

Offline use is another gap. The README describes a web clipper for browsers and a web frontend, but no mobile application and no offline sync. If your capture habit happens on a phone without connectivity, this tool does not address it in the documentation you are given.

Finally, running your own service carries operational cost that a hosted product hides. Backups, database migrations between releases, TLS termination and upgrades are yours. The README does not document rollback, so treat each version bump as a one-way operation until you have read the release notes and the deployment guide.

How Memos differs from a file-based notes app

The obvious alternative for this audience is a plain-Markdown-on-disk approach, where notes are files in a folder that you sync with Git or a file-sync service. The difference in approach is where the source of truth lives. With files, the filesystem is authoritative and any editor can read it; with Memos, the database is authoritative and the API and web UI are the access paths.

That has consequences in both directions. A database gives you consistent writes, a single place to query, and an API that other tools can call without parsing files. It also means you cannot open a note in your editor of choice, and your notes become unreadable if you lose the database and the backups. Files give you portability and trivial backup (copy the directory) at the cost of no server-side API, no shared instance, and no built-in visibility controls.

If your priority is a durable archive you can read in twenty years with no tooling, files win. If your priority is capture speed plus an API you can script against, Memos makes the opposite bet, and the MIT licence means you can read the source to see exactly how that bet is implemented.

Maintenance, releases and what the MIT licence means here

The repository is not archived, and the last push was on 2026-07-26, which coincides with the v0.30.0 release on the same date. Two release candidates, v0.30.0-rc.1 and v0.30.0-rc.2, preceded it in July 2026. That release pattern (candidates first, then a tagged release) is worth knowing if you pin versions in production: you can track the candidates to see what is coming, but the stable tag is the one the README's Docker command uses.

Upgrade cost depends on your deployment method. Docker users pull a new image tag and restart the container; native-binary users rerun the install script or replace the binary. Either way, the database schema may change between versions, and the README does not document a downgrade procedure. Back up the mounted volume before upgrading.

MIT is a permissive licence. You can use, modify and redistribute the code, including in commercial settings, provided the licence and copyright notice are preserved. That is the extent of what the repository states; it is not legal advice, and if you are embedding Memos in a product you should read the LICENSE file and the project's privacy policy rather than relying on a summary.

Editorial conclusion

Adopt Memos if you want a small, Markdown-first capture tool on your own server and are comfortable running a container or a Go binary. Skip it if you need a full document editor, offline mobile sync, or a hosted service with a support contract, because the README describes none of these. Before committing, verify the storage backend you intend to use (SQLite, MySQL or PostgreSQL) against your backup tooling, and confirm the upgrade path for your deployment method in the deployment guide, since the README does not document rollback.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes