
open-zk-kb
Shared, persistent memory for AI assistants, built on the Zettelkasten method
Provides shared, persistent memory for AI assistants using the Zettelkasten method, enabling context to persist across sessions through searchable atomic notes stored locally.
About open-zk-kb
open-zk-kb is a community-built MCP server published by mrosnerr that provides AI assistants with tools and capabilities via the Model Context Protocol. Shared, persistent memory for AI assistants, built on the Zettelkasten method It is categorized under auth security. This server exposes 3 tools that AI clients can invoke during conversations and coding sessions.
How to install
You can install open-zk-kb in your AI client of choice. Use the install panel on this page to get one-click setup for Cursor, Claude Desktop, VS Code, and other MCP-compatible clients. This server runs locally on your machine via the stdio transport.
License
open-zk-kb is released under the MIT license. This is a permissive open-source license, meaning you can freely use, modify, and distribute the software.
Tools (3)
Search the knowledge base for relevant notes using hybrid full-text and semantic search
Save decisions, preferences, procedures, and insights as structured notes in the knowledge base
Review, promote, archive, and rebuild notes to manage the knowledge base lifecycle
open-zk-kb
Shared, persistent memory for AI assistants, built on the Zettelkasten method. One knowledge base for all your tools — so context persists across sessions and clients.
Demo
Real MCP calls — store, search, and stats run against a live knowledge base.
Why open-zk-kb?
AI assistants forget everything between sessions. open-zk-kb gives your assistant a persistent, structured memory it queries automatically.
- Hybrid search — full-text + local embeddings, so only relevant notes surface
- Atomic notes — one concept per note (6 kinds, lifecycle management) keeps results precise
- Local-first — no API keys, works offline, scales to thousands of notes
- Human-readable — Markdown + YAML frontmatter, rebuildable from files
- Shared memory across tools — one knowledge base for OpenCode, Claude Code, Cursor, Windsurf, and Zed
- MIT-licensed
Quick Start
Requires Bun — install with
curl -fsSL https://bun.sh/install | bash
bunx open-zk-kb@latest
That's it. The interactive installer:
- Adds the MCP server to your client config
- Installs knowledge base instructions (skill for Claude Code, managed block for OpenCode/Windsurf)
- Creates a local vault at
~/.local/share/open-zk-kb
Supported clients: OpenCode, Claude Code, Cursor, Windsurf, Zed
How It Works
Your AI assistant gets three MCP tools:
| Tool | What it does |
|---|---|
knowledge-search | Search the knowledge base before starting work |
knowledge-store | Save decisions, preferences, procedures, and insights |
knowledge-maintain | Review, promote, archive, and rebuild notes |
The installer injects instructions that guide the AI to proactively search for relevant context before starting work and store valuable knowledge as it discovers it. No plugin required — the AI drives everything through tool calls.
Notes are stored as Markdown files with YAML frontmatter. A SQLite index provides fast full-text search, with local vector embeddings for semantic matching. No API key needed.
Configuration
Zero configuration required for basic usage. The installer creates ~/.config/open-zk-kb/config.yaml automatically.
To use an API provider for embeddings instead of local models:
embeddings:
provider: "api"
base_url: "https://openrouter.ai/api/v1"
api_key: "your-api-key-here"
model: "openai/text-embedding-3-small"
dimensions: 1536
Any OpenAI-compatible API works (OpenRouter, Together, Groq, local vLLM, etc.). See docs/configuration.md for the full reference.
Note Kinds
| Kind | Default Status | Use Case |
|---|---|---|
personalization | permanent | User preferences, habits, and personal style |
reference | fleeting | Technical facts, API details, and documentation snippets |
decision | permanent | Architectural choices, project commitments, and trade-offs |
procedure | fleeting | Step-by-step workflows and recurring tasks |
resource | permanent | Links, tools, libraries, and external documentation |
observation | fleeting | Insights, patterns, and temporary findings |
Notes follow a lifecycle: fleeting → permanent → archived. See Note Lifecycle for details.
Manual Install
If you prefer manual configuration, add open-zk-kb to your client's MCP config file. No cloning required — the npm package includes everything.
Note: Manual install only adds the MCP server. To also inject the agent instructions, run
bunx open-zk-kb@latest install --client <name>or add the contents ofagent-instructions-full.md(oragent-instructions-compact.mdfor token-constrained clients) to your client's instruction file.
OpenCode
~/.config/opencode/opencode.json
{
"mcp": {
"open-zk-kb": {
"type": "local",
"command": ["bunx", "open-zk-kb@latest", "server"],
"enabled": true
}
}
}
Claude Code
~/.claude/settings.json
{
"mcpServers": {
"open-zk-kb": {
"command": "bunx",
"args": ["open-zk-kb@latest", "server"]
}
}
}
Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"open-zk-kb": {
"command": "bunx",
"args": ["open-zk-kb@latest", "server"]
}
}
}
Windsurf
~/.codeium/windsurf/mcp_config.json
{
"mcpServers": {
"open-zk-kb": {
"command": "bunx",
"args": ["open-zk-kb@latest", "server"]
}
}
}
Zed
~/.config/zed/settings.json
{
"context_servers": {
"open-zk-kb": {
"command": "bunx",
"args": ["open-zk-kb@latest", "server"]
}
}
}
Development
git clone https://github.com/mrosnerr/open-zk-kb
cd open-zk-kb
bun install && bun run build
bun run setup # interactive installer
Links
- Setup Guide — installation, instruction injection, verification
- Tools Reference — all 3 MCP tools, parameters, examples
- Configuration Reference — embeddings, vault, logging
- Note Lifecycle — statuses, review, promotion
- Architecture Design — system design, dual storage, instruction injection
- Development & Contributing — local dev, testing, debugging
- Contributing Guidelines
License
Alternatives
Related Skills
Browse all skillsFirebase gives you a complete backend in minutes - auth, database, storage, functions, hosting. But the ease of setup hides real complexity. Security rules are your last line of defense, and they're often wrong. Firestore queries are limited, and you learn this after you've designed your data model. This skill covers Firebase Authentication, Firestore, Realtime Database, Cloud Functions, Cloud Storage, and Firebase Hosting. Key insight: Firebase is optimized for read-heavy, denormalized data. I
Comprehensive backend development skill for building scalable backend systems using NodeJS, Express, Go, Python, Postgres, GraphQL, REST APIs. Includes API scaffolding, database optimization, security implementation, and performance tuning. Use when designing APIs, optimizing database queries, implementing business logic, handling authentication/authorization, or reviewing backend code.
Expert in secure backend coding practices specializing in input validation, authentication, and API security. Use PROACTIVELY for backend security implementations or security code reviews.
Django security best practices, authentication, authorization, CSRF protection, SQL injection prevention, XSS prevention, and secure deployment configurations.
Spring Security best practices for authn/authz, validation, CSRF, secrets, headers, rate limiting, and dependency security in Java Spring Boot services.
This skill should be used when the user requests to generate, create, or add Row-Level Security (RLS) policies for Supabase databases in multi-tenant or role-based applications. It generates comprehensive RLS policies using auth.uid(), auth.jwt() claims, and role-based access patterns. Trigger terms include RLS, row level security, supabase security, generate policies, auth policies, multi-tenant security, role-based access, database security policies, supabase permissions, tenant isolation.