zen

Zen is a lightweight note-taking server written in Go that stores data in a local SQLite database and exposes a fast, full-text searchable interface. It can run as a single Go binary or via Docker Compose. The server supports organizing notes with flexible tags, rich Markdown rendering (tables, code blocks, task lists, highlights, etc.), templates, pinned notes, archiving, soft deletes, and optional backups. Experimental features include a spatial canvas for organizing notes, semantic search, and image-related capabilities, all accessible through the MCP interface for searching, listing, and reading notes.

To use Zen via MCP, start the server with either a Go binary or a Docker-based setup. Once running, you can query and manage notes using the MCP endpoints provided by the server. The system is designed to be portable (import/export), with lightweight resource usage and an emphasis on local data storage via SQLite. For developers, you can run in development mode for rapid iteration and debugging, or deploy with Docker Compose for production-like environments that mirror the project’s intended usage patterns.

Prerequisites:

• Go tooling if building from source (optional if using Docker): https://golang.org/doc/install
• Docker and Docker Compose for containerized deployment
• Make tool if you want to build using the provided Makefile

Installation steps (Docker Compose):

1. Clone the repository or pull the Zen image from Docker Hub (as per your preference).
2. If using Docker Compose, ensure you have a docker-compose.yml configured to set up the Zen service (sample configurations are typically provided in the repo).
3. Start the service:
   • docker-compose up -d
4. Access the server at the configured host/port (default typically http://localhost:port).

Installation steps (From source):

1. Ensure Go is installed: https://golang.org/doc/install
2. Clone the repository: git clone https://github.com/sheshbabu/zen.git
3. Navigate to the project directory: cd zen
4. Build the binary:
   • make build
5. Run in development mode or with a production-ready configuration:
   • make dev
   • Or run the built binary directly: ./zen
6. If you plan to enable live reloads during development, install and run the required tooling as described in the repository (e.g., air and esbuild) and use the provided make targets such as make watch.

Tips and caveats:

• If using Docker, consider mounting a persistent volume for the SQLite database to preserve data across restarts.
• The system supports imports/exports for portability; use these when migrating notes between environments.
• Backup strategy: leverage the Zen Backup utility (if available) or implement your own scheduled backups of the SQLite database.
• For experimental features (canvas, semantic search, similar images), ensure any required dependencies or services are enabled and accessible in your environment.
• When configuring via MCP, you can switch between running the Go binary directly or using Docker; ensure the chosen path is reflected consistently in your deployment automation.
• Review and adjust memory and CPU constraints if hosting on shared infrastructure; Zen is designed to be lightweight but SQLite performance can be influenced by concurrent access.