enzyme
by byenzyme
README.md
<div align="center">
# 🧬 Enzyme
[](https://discord.gg/nhvsqtKjQd)
[](LICENSE)
[](https://github.com/byenzyme/enzyme/releases/latest)
[](https://github.com/byenzyme/enzyme/releases)
</div>
Enzyme compiles your notes and other knowledge sources into a local index that:
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/))
2. With this context, generate questions (called **catalysts**) and embed them as semantic routes to the whole knowledge base
3. Keeps refreshing, but separates new doc ingestion (local, fast) from catalyst evolution (cheap, periodic)
When your agent passes queries through the catalysts, it gets a more personalized way to get caught up on the knowledge base.
Enzyme saves an editable reading program. `workspace` blocks describe Markdown,
Are.na, and SQLite sources. Existing `vault` programs remain readable.
[**Jev**](https://typesafe.ai/blog/introducing-system-one-models-and-jev)
can generate the Markdown program through a deterministic scan:
```
profile relationships {
seek "what matters between people"
notice ["meaningful exchanges", "shared interests", "unfinished conversations"]
}
workspace "notes" {
source markdown "notes" { path "~/notes" }
question budget 40
sample across time
favor recent periods
learn questions from folder "people"
including linked pages
about relationships
learn questions from folder "meetings" about operational
learn questions from tags ["founding", "ai-ux"] about decisions
learn questions from folder "inbox"
project questions into "~/notes/Readwise"
// Guidance compiled for your agent, not an enforced hook.
when asked {
"Use grep for names, titles, and exact phrases."
retrieve passages through learned questions
answer with sources
}
}
```
For a Markdown folder, the source path remains the runtime and index location.
Changing an existing `vault` program to this form does not move its index.
## Get started
Open your Markdown notes folder in an agent that can run terminal commands, such
as Claude Code or Codex, and paste this prompt. If your agent is open elsewhere,
replace the first sentence with the path to your notes.
```text
Set up Enzyme for the Markdown notes folder I have open. If you cannot identify it, ask me for its path.
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.
You may use Enzyme's online service 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.
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.
```
The agent installs Enzyme, reviews the settings with you, and demonstrates an
answer from your own notes. You can keep writing and organizing your notes as you
already do; cleanup is not a prerequisite.
### Terminal setup
If you prefer to install it yourself:
```bash
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:
```bash
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`:
```bash
enzyme --collection apple-notes compile --preset apple-notes \
"$HOME/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite"
enzyme --collection apple-notes init
```
For Are.na, use `enzyme --collection <name> compile --preset arena <channel-url>`
and then `enzyme --collection <name> init`. Run `refresh` with the
same `--collection` name to pick up later changes.
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` |
## Agent tools for retrieval
`enzyme petri` shows what Enzyme found worth asking about. In an interactive terminal it renders a tree; piped, it emits JSON:
```bash
enzyme petri | jq '.entities[:2]'
```
```json
[
{
"name": "system-design",
"type": "tag",
"activity_trend": "active",
"frequency_12m": 84,
"catalysts": [
{
"text": "What does the commitment to simplicity cost when the pressure to ship keeps winning?",
"context": "velocity vs craft in infrastructure",
"era": "2024-Q3"
},
{
"text": "Where does the analysis of user needs gather information that delays rather than clarifies the core value?",
"context": "research as avoidance",
"era": "2025-Q1"
}
]
},
{
"name": "working-with-others",
"type": "tag",
"activity_trend": "rising",
"frequency_12m": 47,
"catalysts": [
{
"text": "What assumptions about leadership are held by those who are good at building things?",
"context": "craft vs delegation",
"era": "2024-Q4"
},
{
"text": "How does the goal of not depending on others shape the approach to collaboration?",
"context": "independence vs team trust",
"era": "2025-Q2"
}
]
}
]
```
Each entity carries catalysts spanning different eras — questions that cut across months of content.
```bash
enzyme catalyze "why we keep rewriting the auth layer"
```
```json
{
"query": "why we keep rewriting the auth layer",
"results": [
{
"file_path": "retros/2024-q3-platform-retro.md",
"content": "scoped auth extraction as a two-week project for the third time. real blocker wasn't the token service — nobody wanted to own the session model. every proposal added a layer instead of removing one.",
"similarity": 1.46
},
{
"file_path": "adrs/007-auth-service-extraction.md",
"content": "the monolith's session handling has become the bottleneck for every team shipping independently. chose separation of concerns over the coordination cost of a new service boundary.",
"similarity": 1.24
},
{
"file_path": "reading/highlights-accelerate.md",
"content": "'Teams that can deploy independently are twice as likely to be in the high-performer category.' — we keep choosing the rewrite over the boundary.",
"similarity": 1.13
}
],
"top_contributing_catalysts": [
{
"entity": "system-design",
"text": "What does the commitment to simplicity cost when the pressure to ship keeps winning?",
"relevance_score": 0.74
}
]
}
```
*Output above is illustrative — it shows the shape of a result, not a captured run.*
## message archives (_experimental_)
Enzyme indexes SQLite tables alongside Markdown — iMessage, WhatsApp, Mail, or any table of dated rows.
Declare a `source sqlite` inside a named `workspace` program, then run `init`
and periodic `refresh`. The [SQLite source setup skill](https://github.com/byenzyme/enzyme/blob/main/skills/enzyme-sqlite-source/SKILL.md)
shows the source declaration and source-scoped readings.
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.
A source names columns by the role they play rather than by the app they came from:
| Role | Means |
|----------|-------------------------------------------------|
| `id` | the row's identity |
| `who` | participants; scalar, JSON array, or delimited |
| `when` | the row's timestamp |
| `what` | the text to read |
| `where` | the container the row belongs to (optional) |
| `weight` | numeric significance per occurrence (optional) |
## API keys
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.
The first configured vault on a machine initializes without login. Refresh, publishing, account credits, and additional vaults require `enzyme login`.
To bring your own OpenAI-compatible key, pass `--use-env-llm`, which reads `OPENAI_API_KEY` plus optional `OPENAI_BASE_URL` and `OPENAI_MODEL`. Without any hosted or env key, catalyst generation is skipped and indexing, embedding, and local search still work.
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`).
This server cannot be deployed
Maintenance
ActivityActive
ResponsivenessResponsive