memos

Memos is an open-source, self-hosted note-taking tool designed for quick capture of thoughts, ideas, and logs using Markdown, with no vendor lock-in, zero telemetry, and total data ownership.

It deploys as a single Go binary or a ~20MB Docker image and supports SQLite, MySQL, and PostgreSQL as storage backends. The timeline-first interface removes the overhead of folders and hierarchies so you can open the app, write, and move on. Memos ships with full REST and Connect RPC (gRPC-compatible) APIs, Server-Sent Events for real-time updates, a built-in MCP server for AI agent integration, and optional S3-compatible storage for attachments.

The project has grown to over 60,000 GitHub stars and releases updates monthly with active contributions from hundreds of developers. A live demo is available at demo.usememos.com for evaluation without installation. The MIT license means you can run it commercially, fork it, and embed it in your own products without restriction.

What You Get

• Timeline-First UI - Notes appear in reverse-chronological order the moment you save them, eliminating the need to choose a folder or category before you can write anything.
• Total Data Ownership - All notes are stored in your chosen database (SQLite, MySQL, or PostgreSQL) on your own infrastructure with zero telemetry sent to any external service.
• Markdown-Native Editor - The editor supports the full CommonMark and GFM specification including task lists, code blocks, KaTeX math, and embedded media, with live rendering.
• Attachment and Media Support - Upload images, audio, and video directly into notes, with automatic thumbnail generation and EXIF metadata stripping for privacy on images.
• Built-In MCP Server - A production-ready Model Context Protocol endpoint at /mcp lets AI coding assistants (Claude, Cursor, etc.) create, search, and manage memos through standardized tool calls.
• Full API Surface - Complete REST and Connect RPC APIs with generated OpenAPI documentation allow deep integration with scripts, automations, and third-party applications.
• Multi-Database and S3 Storage - Choose SQLite for simplicity, MySQL or PostgreSQL for scale, and optionally offload attachments to any S3-compatible object store.
• Geolocation and Map View - Optionally tag memos with coordinates and view them on an interactive map, useful for travel notes or location-specific observations.

Common Use Cases

• Developer daily logging - A software engineer captures debugging findings, API responses, architecture decisions, and deployment notes throughout the day, keeping a searchable personal knowledge base without relying on a corporate SaaS tool.
• AI agent knowledge store - A developer configures Claude or another MCP-capable AI assistant to write structured notes into Memos automatically during coding sessions, creating a persistent audit trail of AI-generated insights.
• Self-hosted personal journal - A privacy-conscious individual runs Memos on a home server or VPS to maintain a daily journal in Markdown, knowing the data never leaves their control and is always readable as plain text.
• Team internal microblog - A small remote team shares project updates, links, and quick decisions in a shared Memos instance, replacing group chat noise with a searchable, tagged timeline.
• Research and reading notes - A researcher clips quotes, pastes citations, and annotates papers as Memos entries tagged by topic, building a personal Zettelkasten without complex tooling.

Under The Hood

Architecture Memos follows a clean layered architecture where the Echo v5 HTTP server, Connect RPC handlers, and gRPC-gateway all share a single store abstraction, preventing any one transport from coupling to storage logic. The server/router/api/v1 layer handles all inbound requests through service structs that receive the store as a dependency injected at construction time, making the services straightforward to test in isolation. Background work — scheduled tasks, S3 pre-sign rotation, webhook dispatch, email notifications — runs in separate runner goroutines managed by the Server struct with controlled cancellation and wait groups, ensuring clean shutdown. The MCP server is an architectural highlight: rather than duplicating API logic, it drives the existing Echo server in-process via an httptest adapter, using the generated OpenAPI specification as the single source of truth for tool schemas, which means every new API endpoint can become an AI tool by adding one line to an allowlist.

Tech Stack The backend is written in Go 1.26 with the Echo v5 web framework and uses connectrpc.com/connect for type-safe Connect RPC, complemented by grpc-gateway for HTTP/JSON transcoding from protobuf service definitions. Storage is accessed through a unified driver interface that supports SQLite (via go-sqlite3), MySQL, and PostgreSQL, with database migrations managed in SQL files per driver. Attachments can be stored locally or delegated to any S3-compatible service using the AWS SDK v2. The frontend is React 19 with TypeScript, bundled by Vite 8 and managed with React Query v5 for server state; styles use Tailwind CSS v4. The AI integration layer uses the OpenAI Go SDK v3 and supports speech-to-text via a pluggable STT interface, making it model-agnostic. Containerization is a single-stage Dockerfile producing a compact image, and deployment is documented for Docker Compose, Kubernetes, and native binaries.

Code Quality The codebase maintains extensive test coverage with over 100 Go test files covering service logic, ACL enforcement, SSE hub behavior, MCP protocol compliance, and database-layer operations through testcontainers for real database testing. Error handling is explicit throughout: Go errors are propagated with pkg/errors wrapping for context, and the MCP layer carefully distinguishes between protocol errors and tool errors, returning structured error results rather than crashing the handler. TypeScript on the frontend is strict and the protobuf-generated types shared between Go and TypeScript ensure the API contract is enforced at compile time on both sides. The repository uses golangci-lint with a broad ruleset and the frontend follows ESLint conventions enforced in CI.

What Makes It Unique The built-in MCP server is the most distinctive recent addition: Memos is one of the few self-hosted applications that ships a first-class, specification-compliant MCP endpoint derived directly from its OpenAPI surface, meaning AI assistants can interact with your notes using the same authentication and authorization as the REST API with no additional configuration. The Connect RPC adoption (replacing raw gRPC) gives the API HTTP/1.1 compatibility without a sidecar proxy, and the shared in-process request execution in the MCP adapter eliminates an entire network hop. The focus-mode overlay, sliding-window refresh token rotation, and EXIF metadata stripping on upload reflect a consistent attention to privacy and writing experience that distinguishes Memos from generic note-taking backends.

Self-Hosting

Memos is released under the MIT License, which is one of the most permissive open-source licenses available. You are free to use it commercially, modify the source code, redistribute it, and embed it in proprietary products without any obligation to open-source your changes or pay licensing fees. There are no enterprise tiers, no feature flags behind a paywall, and no license-check mechanisms in the codebase — every feature in the repository is available to every self-hoster from day one.

Running Memos yourself is genuinely lightweight compared to most self-hosted applications. The Go binary is statically compiled with no external runtime, and the Docker image is compact. A single-user instance runs comfortably on a $5 VPS or a Raspberry Pi. For production use you will want to handle your own reverse proxy (Nginx, Caddy, or Traefik are common choices), TLS termination, database backups, and container restart policies. SQLite works well for personal use; migrating to MySQL or PostgreSQL is supported if you need concurrent multi-user writes at scale. There are no automated migration tools between database backends, so that is a one-time manual operation if you switch. The project does not provide a hosted or managed version, so all operational responsibility — uptime, updates, backups, and incident response — falls to you.

There is no official cloud or SaaS tier of Memos. The trade-off versus a hosted note-taking service is therefore not about feature parity but about operational overhead and convenience. You will not receive SLAs, managed upgrades, or 24/7 support. The community is active on GitHub and Discord, and the project releases monthly, but patches must be applied manually by pulling a new Docker image. If your primary concern is reducing maintenance burden rather than data sovereignty, a managed alternative like Notion or Obsidian Sync may suit you better.