Skip to content
Back to search

enzyme

MarketplaceWorks with Claude CodeGitHub

Local-first compile step for knowledge bases. Save 350x cost, 1000x speed vs. frontier models

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/byenzyme/enzyme with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/byenzyme/enzyme'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/byenzyme--enzyme/badge.svg)](/listings/byenzyme--enzyme)

HTML

<a href="/listings/byenzyme--enzyme"><img src="/api/listings/byenzyme--enzyme/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

If you prefer to install it yourself:

curl -fsSL https://raw.githubusercontent.com/byenzyme/enzyme/main/install.sh | bash
cd /path/to/your/notes
enzyme install claude # or: codex, hermes, openclaw

Then use the prompt above. For setup without an agent:

enzyme compile -v
# Review the .enzyme settings file at the path printed by compile.
enzyme init --quiet
enzyme doctor
enzyme petri --query "a question about your notes"
enzyme catalyze "a question about your notes"

For Markdown notes, run `enzyme compile` and review the settings file it saves before `enzyme init` builds the local index.

For Apple Notes, a preset builds a named `workspace` program from your Notes database. Review the saved `.enzyme` program before running `init`:

enzyme --workspace apple-notes compile --preset apple-notes \
  "$HOME/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite"
enzyme --workspace apple-notes init

For Are.na, use `enzyme --workspace <name> compile --preset arena <channel-url>` and then `enzyme --workspace <name> init`. Run `refresh` with the same `--workspace` name to pick up later changes (`--collection` is an accepted alias).

Scripts and host apps can rely on defined exit codes (0 ok, 1 runtime failure, 2 usage, 3 configuration, 4 workspace busy, 5 `init` indexed but catalysts failed their quality gate). Concurrent `init`/`refresh` calls on one workspace wait for each other, bounded by `--lock-timeout`.

Enzyme was built for knowledge bases that grow rapidly:

* Agent memory corpora * Zettelkasten practices in Obsidian that accumulate new dated notes into singular folders * Meeting transcriptions built around AI-native, Markdown CRM setups.

It's designed to support knowledge captures that might be later be important, even if they don't serve a current task. Enzyme is focused on doing one thing well: **giving agents the tools to make ideas compound**.

And it ships with a set of `profiles` designed around a personal knowledge base, that were refined over [2 years of personal use](https://joshpham.com/kit/how-i-use-enzyme). Here are some examples of how they are used:

| Read... | For... | Profile | |--------------------------|-------------------------------------------------|-----------------------| | Project notes | what's stuck and what keeps blocking | `operational` | | Decision records | why a choice won, what would change it | `decision_trace` | | Saved articles | connections to what you're already working on | `resonance_trace` | | Journals | what keeps returning across entries | `reflective` | | People notes | what matters in these relationships | `relational` | | Feedback / activity logs | what works for you, under what constraints | `preference_evidence` | | *(default)* | costs, assumptions, live tensions | `tension_trace` |

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 232 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. # 🧬 Enzyme
  3. [![Discord](https://img.shields.io/discord/1191288276536008745?label=Discord&logo=discord&style=flat-square)](https://discord.gg/nhvsqtKjQd)
  4. [![License](https://img.shields.io/github/license/byenzyme/enzyme?style=flat-square)](LICENSE)
  5. [![Release](https://img.shields.io/github/v/release/byenzyme/enzyme?style=flat-square)](https://github.com/byenzyme/enzyme/releases/latest)
  6. [![Downloads](https://img.shields.io/github/downloads/byenzyme/enzyme/total?style=flat-square&label=Downloads&color=6c757d)](https://github.com/byenzyme/enzyme/releases)
  7. </div>
  8. Enzyme compiles your notes and other knowledge sources into a local index that:
  9. 1. Uses temporally grounded context sampling that captures the contextual use of tags and wikilinks, or natural accumulation in folders (i.e. pseudo-[Zettelkasten](https://zettelkasten.de/introduction/))
  10. 2. With this context, it "dreams" questions in the background (called **catalysts**) and embeds them. At query time, each question finds its nearest docs, so it avoid needing to "dream" full summaries. (see note)
  11. 3. Keeps refreshing, but separates new doc ingestion (local, fast) from catalyst evolution (cheap, periodic)
  12. The catalysts help orient the agent to the wiki. Enzyme saves up to 50% tokens vs. plain agentic search with grep.
  13. <picture>
  14. <source media="(prefers-color-scheme: dark)" srcset="docs/assets/enzyme-loop-dark.gif">
  15. <img src="docs/assets/enzyme-loop.gif" width="880" alt="Notes and agent-written memories that mention a person arrive over time. Enzyme writes one question from them once, and later notes attach to it without rewriting it. When a query comes in, the agent reads the relevant questions, aims two searches at the periods they point to, and gets back passages from across those years.">
  16. </picture>
  17. *(Note: your system may already generate lots of memories in different buckets; Enzyme catalysts help thread them together)*
  18. ## Get started
  19. Open your Markdown notes folder with your agent and paste this prompt.
  20. ```text
  21. Set up Enzyme for the Markdown notes folder I have open. If you cannot identify it, ask me for its path.
  22. Install Enzyme if needed using https://raw.githubusercontent.com/byenzyme/enzyme/main/install.sh, and install the instructions for this agent. Read and follow the installed enzyme-workspace-setup skill.
  23. Use it to suggest settings from my notes and prepare search. Show me what you propose to include or exclude, and let me correct it before building the local search index.
  24. Then answer one useful question using my notes, with links to the sources, and suggest a question I can ask next. Keep my existing notes in place and unchanged. Ask separately before any cleanup, model download, or recurring task.
  25. ```
  26. After setup, keep working with your agent as usual. The new guidance tells your agent how to use Enzyme and when to refresh it.
  27. Prefer to install it yourself first? Run this, then paste the same prompt:
  28. ```bash
  29. curl -fsSL https://raw.githubusercontent.com/byenzyme/enzyme/main/install.sh | bash
  30. cd /path/to/your/notes
  31. enzyme install claude # or: codex, hermes, openclaw
  32. ```
  33. ## What it's for
  34. Enzyme was built for knowledge bases that grow quickly:
  35. * Obsidian vaults that accumulate dated notes in a few folders
  36. * Meeting notes and AI-native, Markdown CRM setups
  37. * Agent memory written as Markdown
  38. At setup time, it proposes a `.enzyme` program by reading your wiki and existing agent instructions, like:
  39. ```
  40. profile relationships {
  41. seek "what matters between people"
  42. notice ["meaningful exchanges", "shared interests", "unfinished conversations"]
  43. }
  44. workspace "notes" {
  45. source markdown "notes" { path "~/notes" }
  46. question budget 40
  47. sample across time
  48. favor recent periods
  49. learn questions from folder "people"
  50. including linked pages
  51. about relationships
  52. learn questions from folder "meetings" about operational
  53. learn questions from tags ["startup", "design"] about decisions
  54. learn questions from folder "inbox"
  55. project questions into "~/notes/Readwise"
  56. // Guidance compiled for your agent, not an enforced hook.
  57. when asked {
  58. "Use grep for names, titles, and exact phrases."
  59. retrieve passages through learned questions
  60. answer with sources
  61. }
  62. }
  63. ```
  64. And you can give feedback to modify the program.
  65. Enzyme helps most when a question spans many notes written over time: context for a decision on a project, or a broader theme arising from conversations with one person. It's designed to support knowledge captures that might be later be important, even if they don't serve a current task. Enzyme is focused on doing one thing well: **giving agents the tools to make ideas compound**. And it ships with a set of `profiles` designed around a personal knowledge base
  66. were refined over [2 years of personal use](https://joshpham.com/kit/how-i-use-enzyme):
  67. | Read... | For... | Profile |
  68. |--------------------------|-------------------------------------------------|-----------------------|
  69. | Project notes | what's stuck and what keeps blocking | `operational` |
  70. | Decision records | why a choice won, what would change it | `decision_trace` |
  71. | Saved articles | connections to what you're already working on | `resonance_trace` |
  72. | Journals | what keeps returning across entries | `reflective` |
  73. | People notes | what matters in these relationships | `relational` |
  74. | Feedback / activity logs | what works for you, under what constraints | `preference_evidence` |
  75. | *(default)* | costs, assumptions, live tensions | `tension_trace` |
  76. ## Reference
  77. ### Setup without an agent
  78. ```bash
  79. enzyme compile -v
  80. # Review the .enzyme settings file at the path printed by compile.
  81. enzyme init --quiet
  82. enzyme doctor
  83. enzyme catalyze "a question about your notes"
  84. ```
  85. `compile` proposes settings and saves them; `init` builds the local index from
  86. them; `doctor` reports what was indexed and any problems.
  87. ### Other sources
  88. For Apple Notes, a preset builds a named `workspace` program from your Notes
  89. database. Review the saved `.enzyme` program before running `init`:
  90. ```bash
  91. enzyme --workspace apple-notes compile --preset apple-notes \
  92. "$HOME/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite"
  93. enzyme --workspace apple-notes init
  94. ```
  95. For Are.na, use `enzyme --workspace <name> compile --preset arena <channel-url>`
  96. and then `enzyme --workspace <name> init`. Run `refresh` with the
  97. same `--workspace` name to pick up later changes (`--collection` is an accepted
  98. alias).
  99. ### Retrieval commands
  100. `enzyme petri` shows what Enzyme found worth asking about. In a terminal it renders a tree; piped, it emits JSON.
  101. ```bash
  102. enzyme petri -n 2
  103. ```
  104. ```text
  105. Petri
  106. ├─ #working-with-others · tag · active · 11 mentions
  107. │ └─ catalysts
  108. │ ├─ Why did every auth change still route through me after I kept promising to write it down?
  109. │ ├─ Why did the third auth extraction attempt stall when nobody wanted to own the session model?
  110. │ ├─ Which reasons for handing the session model to Maya had I stopped believing by then?
  111. │ ├─ Did extraction stay paused once Maya's team owned the session model?
  112. │ └─ …
  113. └─ #system-design · tag · active · 10 mentions
  114. └─ catalysts
  115. ├─ Why did I pick a monolith with inner module boundaries over splitting services yet?
  116. ├─ Did I ever settle who owns the session model once auth moves out?
  117. ├─ Which part of auth extraction kept adding layers instead of removing one?
  118. ├─ Does my view that independence means who can change what still hold?
  119. └─ …
  120. ```
  121. An agent reads this map first, then searches. `enzyme catalyze` ranks notes by wording and meaning together, and each result carries the catalyst that best connects it to the query:
  122. ```bash
  123. enzyme catalyze -n 3 "why we keep rewriting the auth layer" \
  124. | jq '{search_strategy, results: [.results[] | {file_path, similarity, via_catalyst_text, content}]}'
  125. ```
  126. ```json
  127. {
  128. "search_strategy": "hybrid",
  129. "results": [
  130. {
  131. "file_path": "retros/2025-q3-platform-retro.md",
  132. "similarity": 0.817,
  133. "via_catalyst_text": "Why did I keep scoping auth extraction as a two-week project, and what kept stalling it?",
  134. "content": "# Q3 platform retro\n#system-design #working-with-others\n\nScoped auth extraction as a two-week project for the third time. The real blocker was not the token service; nobody wanted to own the session model. Every proposal added a layer instead of removing one. Action: decide ownership before touching code again."
  135. },
  136. {
  137. "file_path": "journal/2025-05-12.md",
  138. "similarity": 0.693,
  139. "via_catalyst_text": "Why did every auth change still route through me after I kept promising to write it down?",
  140. "content": "#working-with-others\n\nReviewed eleven PRs today and wrote none. Every auth change still routes through me because I wrote the session code and nobody else wants to touch it. I keep saying I will write it down so someone else can own it. I have not."
  141. },
  142. {
  143. "file_path": "1on1s/2026-01-maya.md",
  144. "similarity": 0.579,
  145. "via_catalyst_text": "What keeps pulling me back to rewriting when Maya's smaller version already worked?",
  146. "content": "# 1:1 with Maya\n#working-with-others\n\nMaya replaced the token refresh path with something half the size of mine. She asked me twice and then stopped asking, which is the point. I want to do this with billing before I start rewriting it myself."
  147. }
  148. ]
  149. }
  150. ```
  151. ### Message archives (_experimental_)
  152. Enzyme indexes SQLite tables alongside Markdown — iMessage, WhatsApp, Mail, or any table of dated rows.
  153. Declare a `source sqlite` inside a named `workspace` program, then run `init`
  154. and periodic `refresh`. The [SQLite source setup skill](https://github.com/byenzyme/enzyme/blob/main/skills/enzyme-sqlite-source/SKILL.md)
  155. shows the source declaration and source-scoped readings.
  156. None of these is a special case. A `handle_id` column is repeated person values across dated rows, the same way `[[links]]` are repeated person values across dated notes. Both collapse to entity occurrences with effective dates, and nothing downstream knows which one it came from: the same profiles, budgets, and catalysts apply to a message thread and a folder of meeting notes.
  157. A source names columns by the role they play rather than by the app they came from:
  158. | Role | Means |
  159. |----------|-------------------------------------------------|
  160. | `id` | the row's identity |
  161. | `who` | participants; scalar, JSON array, or delimited |
  162. | `when` | the row's timestamp |
  163. | `what` | the text to read |
  164. | `where` | the container the row belongs to (optional) |
  165. | `weight` | numeric significance per occurrence (optional) |
  166. ### API keys
  167. Enzyme needs an API key only for catalyst generation and for Markdown `enzyme compile`'s selection step. Source preset compilation does not call a model. By default `enzyme init` uses Enzyme's hosted bootstrap and ignores inherited `OPENAI_*` variables so it does not spend your personal key. Credential resolution is explicit key → configured local model → anonymous brokered free config, with no additional configuration.
  168. The first configured vault on a machine initializes without login. Refresh, publishing, account credits, and additional vaults require `enzyme login`.
  169. To bring your own OpenAI-compatible key, pass `--llm env` (alias `--use-env-llm`), which reads only `OPENAI_API_KEY` plus optional `OPENAI_BASE_URL` and `OPENAI_MODEL`. `init` and `refresh` also take `--llm local` (the installed local model; fails if none is installed), `--llm hosted`, and `--llm none` (index, embed, and select without generating catalysts). Without `--llm` and without any hosted or env key, catalyst generation is skipped and indexing, embedding, and local search still work.
  170. A model served on your own machine (LM Studio, Ollama, a llama.cpp server) works through `--llm env` with `OPENAI_BASE_URL` pointing at it; `OPENAI_API_KEY` must be non-empty even if the server ignores it. Enzyme treats localhost addresses like its built-in 135M model: a compact prompt, at most 10 excerpts per entity, one call per entity, and a 512-token output cap. That includes a proxy on localhost in front of a remote provider. For a larger model, set `ENZYME_LOCAL_MODEL=0` to send it the same prompts and job splitting as hosted generation (`ENZYME_LOCAL_MODEL=1` does the reverse for a small fine-tune hosted elsewhere). That path runs up to 8 calls at once and each request must finish within 120 seconds, so on a slower model set `ENZYME_LLM_CONCURRENCY` to what the server handles and lower `ENZYME_CATALYST_MAX_QUESTIONS_PER_CALL` to keep each call short.
  171. Markdown `enzyme compile` is an explicit OpenRouter Decisions operation. It reuses the hosted lease from `enzyme login` and the free-config broker; an explicit `OPENAI_API_KEY` with `OPENAI_BASE_URL=https://openrouter.ai/api/v1` takes precedence. Catalyst generation uses `OPENAI_MODEL`; Decisions uses `ENZYME_JEV_MODEL` (default `typesafe/jev-1.13`).
  172. ## License
  173. Enzyme is licensed under the [Apache License 2.0](LICENSE).
agent/install.sh · Bundled script · 157 lines · 1 finding marked
  1. #!/usr/bin/env bash
  2. # Install enzyme — local-first knowledge indexing for markdown vaults
  3. # Usage: curl -fsSL https://raw.githubusercontent.com/byenzyme/enzyme/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 3 on GitHub
  4. set -euo pipefail
  5. REPO="byenzyme/enzyme"
  6. INSTALL_DIR="$HOME/.local/bin"
  7. # Detect platform
  8. case "$(uname -s)-$(uname -m)" in
  9. Darwin-arm64) TARGET="macos-arm64" ;;
  10. Darwin-x86_64) TARGET="macos-x86_64" ;;
  11. Linux-x86_64) TARGET="linux-x86_64" ;;
  12. Linux-aarch64) TARGET="linux-arm64" ;;
  13. *)
  14. echo "Unsupported platform." >&2
  15. exit 1 ;;
  16. esac
  17. # Fetch latest version
  18. VERSION="$(curl -fsSL -o /dev/null -w '%{url_effective}' "https://github.com/${REPO}/releases/latest")"
  19. VERSION="${VERSION##*/}"
  20. echo "Installing enzyme ${VERSION} (${TARGET})..."
  21. # Download and extract
  22. tmpdir="$(mktemp -d)"
  23. trap 'rm -rf "$tmpdir"' EXIT
  24. archive="enzyme-${TARGET}.tar.gz"
  25. archive_url="https://github.com/${REPO}/releases/download/${VERSION}/${archive}"
  26. curl -fsSL -o "$tmpdir/$archive" "$archive_url"
  27. # Verify against the checksum published with the release before extracting.
  28. expected="$(curl -fsSL "${archive_url}.sha256" | awk '{print $1}')"
  29. if command -v sha256sum >/dev/null 2>&1; then
  30. actual="$(sha256sum "$tmpdir/$archive" | awk '{print $1}')"
  31. else
  32. actual="$(shasum -a 256 "$tmpdir/$archive" | awk '{print $1}')"
  33. fi
  34. if [ -z "$expected" ] || [ "$expected" != "$actual" ]; then
  35. echo "Checksum verification failed for ${archive}; not installing." >&2
  36. exit 1
  37. fi
  38. tar xzf "$tmpdir/$archive" -C "$tmpdir"
  39. # Install
  40. mkdir -p "$INSTALL_DIR"
  41. mv "$tmpdir/enzyme" "$INSTALL_DIR/enzyme"
  42. chmod +x "$INSTALL_DIR/enzyme"
  43. # Install bundled libraries (Linux builds include lib/ with libstdc++)
  44. if [ -d "$tmpdir/lib" ]; then
  45. mkdir -p "$INSTALL_DIR/lib"
  46. cp -f "$tmpdir/lib/"* "$INSTALL_DIR/lib/"
  47. fi
  48. # Remove legacy generated embedding model cache. Current Enzyme uses the
  49. # compiled-in ESE backend, so these files are stale app state, not user data.
  50. legacy_model_dir="$HOME/.cache/enzyme/models"
  51. if [ -d "$legacy_model_dir" ] && \
  52. { [ -f "$legacy_model_dir/model.safetensors" ] || \
  53. [ -f "$legacy_model_dir/tokenizer.json" ] || \
  54. [ -f "$legacy_model_dir/config.json" ]; }; then
  55. rm -rf "$legacy_model_dir"
  56. fi
  57. # Clean up legacy enzyme-python installation
  58. legacy=""
  59. if [ -d "$HOME/.local/lib/enzyme" ]; then
  60. rm -rf "$HOME/.local/lib/enzyme"
  61. legacy="1"
  62. fi
  63. if [ -f "$HOME/.local/bin/enzyme-mcp" ]; then
  64. rm -f "$HOME/.local/bin/enzyme-mcp"
  65. legacy="1"
  66. fi
  67. # Remove old MCP server entries from Claude Code, Claude Desktop, Codex
  68. if command -v claude &>/dev/null; then
  69. claude mcp remove enzyme -s user 2>/dev/null && legacy="1"
  70. fi
  71. for config in \
  72. "$HOME/Library/Application Support/Claude/claude_desktop_config.json" \
  73. "$HOME/.config/Claude/claude_desktop_config.json"; do
  74. if [ -f "$config" ] && grep -q '"enzyme"' "$config"; then
  75. python3 -c "
  76. import json, sys
  77. p = sys.argv[1]
  78. with open(p) as f: c = json.load(f)
  79. if 'mcpServers' in c and 'enzyme' in c['mcpServers']:
  80. del c['mcpServers']['enzyme']
  81. with open(p, 'w') as f: json.dump(c, f, indent=2)
  82. " "$config" 2>/dev/null && legacy="1"
  83. fi
  84. done
  85. codex_config="$HOME/.codex/config.toml"
  86. if [ -f "$codex_config" ] && grep -q 'mcp_servers\.enzyme' "$codex_config"; then
  87. python3 -c "
  88. import sys
  89. lines = open(sys.argv[1]).readlines()
  90. skip, out = False, []
  91. for line in lines:
  92. if line.strip() == '[mcp_servers.enzyme]':
  93. skip = True
  94. continue
  95. if skip and line.strip().startswith('['):
  96. skip = False
  97. if not skip:
  98. out.append(line)
  99. open(sys.argv[1], 'w').writelines(out)
  100. " "$codex_config" 2>/dev/null && legacy="1"
  101. fi
  102. [ -n "$legacy" ] && echo "Cleaned up legacy enzyme-python installation."
  103. # Track install (non-blocking, best-effort)
  104. curl -sfSo /dev/null -X POST https://api.enzyme.garden/telemetry/plugin-install \
  105. -H "Content-Type: application/json" \
  106. -d "{\"platform\":\"${TARGET}\",\"version\":\"${VERSION}\"}" 2>/dev/null &
  107. echo "Installed to ${INSTALL_DIR}/enzyme"
  108. # Check PATH
  109. case ":$PATH:" in
  110. *":${INSTALL_DIR}:"*) ;;
  111. *) echo "Add to PATH: export PATH=\"${INSTALL_DIR}:\$PATH\"" ;;
  112. esac
  113. # First vault initialization can use Enzyme's hosted bootstrap without login.
  114. # Login remains available for refresh, additional vaults, publishing, and account credits.
  115. if [ ! -f "$HOME/.enzyme/auth.json" ]; then
  116. echo ""
  117. echo "No login required for your first vault init. Later, run: enzyme login"
  118. fi
  119. echo ""
  120. echo "Next: install agent instructions from your notes folder."
  121. echo ""
  122. echo " cd /path/to/your/notes"
  123. echo " enzyme install claude # Claude Code"
  124. echo " enzyme install codex # Codex / Pi / generic .agents"
  125. echo " enzyme install hermes # Hermes (experimental)"
  126. echo " enzyme install openclaw # OpenClaw (experimental)"
  127. echo ""
  128. echo "Already set up? Run it again to update the agent instructions."
  129. echo ""
  130. echo "Agents: read the installed enzyme-workspace-setup skill and follow it."
  131. echo "It covers settings, review with the user, indexing, and a first answer."
  132. echo ""
  133. echo "Setting up by hand? Paste the setup prompt from https://byenzyme.com/setup"
  134. echo "into your agent, or run: enzyme compile -v, review the saved settings,"
  135. echo "then enzyme init."

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.