Kindex
The memory layer AI coding agents don't have.
Kindex does one thing. It knows what you know.
It's a persistent knowledge graph for AI-assisted workflows. It indexes your conversations, projects, and intellectual work so that Claude Code, Codex, Gemini CLI, Google Antigravity, OpenCode, Cursor, and other MCP-capable agents never start a session blind. Available as a free MCP plugin or standalone CLI.
Memory plugins capture what happened. Kindex captures what it means and how it connects. Most memory tools are session archives with search. Kindex is a weighted knowledge graph that grows intelligence over time — understanding relationships, surfacing constraints, and managing exactly how much context to inject based on your available token budget.
Docs: kindex.tools is the canonical public site, served by the companion Fly static app. This repo also publishes its docs/ directory at jmcentire.github.io/kindex. Human setup lives in docs/human-guide.md; agent operating rules live in docs/mcp-agent-guide.md.
Install
Pick whichever installer you already use. They all install the same kin and kin-mcp binaries.
Upgrading to v0.36.0
[!WARNING] Before upgrading, stop every Kindex daemon, MCP server, and older CLI process. A v0.35.x process does not reject schema v12 and can write non-canonical session paths after migration.
Dream is Kindex's background knowledge-consolidation pass: it finds related
nodes, safely merges strong duplicates, and stages weaker links for review.
The first v0.36.0 process to open an older graph creates a transaction-safe
pre-migration snapshot under
$XDG_STATE_HOME/kindex/snapshots/<db>-<hash>/migrations/ (defaulting below
~/.local/state/kindex/snapshots/) before atomically migrating schema v11 to
v12. The owner-private snapshot passes SQLite integrity and source-version
checks, and a partial file is deleted if creation or validation fails.
Concurrent v0.36+ processes serialize this step through a dedicated
rollback-journal SQLite lock and recheck the schema after waiting. Migration
recovery points are retained outside the rotating ten-file
automated-merge snapshot pool. Older duplicate active session tags become paused
history, one active tag per normalized project and name is enforced, and Dream
suggestions carry an explicit title-or-node-ID identity contract and title
ambiguity is refused. No node or edge rows are deleted; legacy
domain-co-membership edges remain available as stored history but no longer
participate in semantic traversal or health metrics. kin status exposes the
durably recorded recovery path; normal stores also record it in kin changelog.
Rolling back the schema migration
Do not open the migrated database with v0.35.x: that version has no forward-schema guard and can write old, non-canonical session identity. Instead:
- While v0.36 is still installed, run
kin statusand record theRecoverypath. It names the latest validated migration attempt; older attempts remain in the samemigrations/directory. - Stop every Kindex process again.
- Move the live database's
-waland-shmsidecars aside. - Copy the recorded snapshot over the live database.
- Only then install or run v0.35.x and verify the graph.
This differs from recovering a bad automated merge,
which does not change package versions. Graph-health consumers must also
recalibrate: existing node/edge/orphan/component outputs now describe the
semantic graph, while explicit stored counts expose retained lifecycle and
legacy rows. Machine-readable stats identify this contract as metrics_schema: 2.
Then initialize the graph:
Extras — combine in one install ('kindex[mcp,llm,reminders]') or use 'kindex[all]':
| Extra | Adds |
|---|---|
mcp | kin-mcp MCP server (for Claude Code, Codex, Gemini, Antigravity, OpenCode, Cursor, etc.) |
llm | Anthropic-powered extraction (kin learn, kin ask) |
vectors | sqlite-vec for semantic similarity search |
reminders | Natural-language time parsing for kin remind |
all | Everything above |
Homebrew and apt packages aren't published yet. Use
pip,uv tool,uvx, or source until they are.
Install as Agent MCP Plugin
Each agent reads MCP servers from a different config file. The kin setup-*-mcp commands write the right shape into the right path; the manual snippet is shown alongside in case you'd rather edit the file yourself.
Claude Code
Or add .mcp.json to any repo for project-scope access:
The MCP server exposes 50+ native tools to supported clients: search, add, context, show, ask, learn, link, edit, supersede, list_nodes, status, suggest, candidate_*, verify, invalidate, stale_check, graph_stats, graph_merge, dream, changelog, ingest, tag_start, tag_update, tag_resume, task_claim, coord_*, lock_acquire, lock_release, remind_*, mode_*, and more.
For coding agents, install both the MCP server and the instruction file. The
instruction file tells the model how to use kindex: start a session tag, read
tracked .kin/config, check project policy, search before adding, capture
durable decisions, and end the tag with a summary.
Codex
setup-codex-hooks installs a SessionStart hook (alongside the prompt/tool attention hooks), so Codex begins each session with the same auto-primed context and "use kindex" / .kin directive as Claude Code.
Or hand-edit ~/.codex/config.toml:
Gemini CLI
Or hand-edit ~/.gemini/settings.json:
Google Antigravity
setup-antigravity-mcp writes the standalone MCP config shape used by
Antigravity's editor/shared config and CLI config. setup-antigravity-hooks
installs PreInvocation priming/prompt checks, PreToolUse advisory attention and
permission gating for Kindex config writes, and Stop-time reinforcement enqueue.
Or hand-edit ~/.gemini/config/mcp_config.json and
~/.gemini/antigravity-cli/mcp_config.json:
OpenCode
Or hand-edit ~/.config/opencode/opencode.json:
OpenCode reads AGENTS.md natively, so install the MCP server and the shared AGENTS.md instructions together.
OpenCode also supports plugins, but Kindex currently uses MCP + instructions there rather than prompt-time attention injection.
Cursor
Or hand-edit ~/.cursor/mcp.json:
Cursor integration is MCP + always-applied rules. Cursor rules provide prompt-level guidance, but Kindex does not currently install a Cursor prompt-submit hook because Cursor does not expose the same hook surface as Claude Code or Codex CLI.
Why Kindex
Context-aware by design
Five context tiers auto-select based on available tokens. When other plugins dump everything into context, Kindex gives you 200 tokens of executive summary or 4000 tokens of deep context — whatever fits. Your plugin doesn't eat the context window.
| Tier | Budget | Use Case |
|---|---|---|
| full | ~4000 tokens | Session start, deep work |
| abridged | ~1500 tokens | Mid-session reference |
| summarized | ~750 tokens | Quick orientation |
| executive | ~200 tokens | Post-compaction re-injection |
| index | ~100 tokens | Existence check only |
Knowledge graph, not log file
Nodes have types, weights, domains, and audiences. Edges carry provenance and decay over time. The graph understands what matters — not just what was said.
Operational guardrails
Constraints block deploys. Directives encode preferences. Watches flag attention items. Checkpoints run pre-flight. No other memory plugin has this.
Cache-optimized LLM retrieval
Three-tier prompt architecture with Anthropic prompt caching. Stable knowledge (codebook) is cached at 10% cost. Query-relevant context is predicted via graph expansion and cached per-topic. Only the question pays full price. Transparent — kin ask just works better and cheaper.
Team and org ready
.kin inheritance chains let a service repo inherit from a platform context, which inherits from an org voice. Private/team/org/public scoping with PII stripping on export. Enterprise-ready from day one.
In Practice
A 162-file fantasy novel vault — characters, locations, magic systems, plot outlines — ingested in one pass. Cross-referenced by content mentions. Searched in milliseconds.
192 nodes. 11,802 edges. 5 context tiers. Hybrid FTS5 + graph traversal in 142ms.
Getting Agents to Actually Use It
Installing the MCP plugin gives the agent the tools. But agents won't use them proactively unless you tell them to. Kindex ships with recommended instruction blocks that turn passive tools into active habits. For the full agent playbook, see docs/mcp-agent-guide.md.
This adds session lifecycle rules (start/orient/during/segment/end), explicit capture triggers (discoveries, decisions, tasks, key files, notable outputs), and search-before-add discipline. The difference between "the agent has a knowledge graph" and "the agent actively maintains a knowledge graph" is this block.
For durable work, agents should use Kindex's persistent task and knowledge
surfaces rather than host-session-only task state. Use task_add, task_list,
and task_done for work that must survive the current conversation; search
before adding knowledge; prefer edit or supersede over duplicate nodes; and
treat tracked .kin files as shipped project state, not local cache.
If the host also exposes session-local task tools, use those only for temporary
planning; durable work belongs in Kindex.
The Claude SessionStart hook (kin setup-hooks) and Codex hooks (kin setup-codex-hooks) reinforce these directives at the start of supported sessions with a "Session directives" block that reminds the agent to use kindex MCP tools throughout the session.
What gets captured
With the directives active, the agent will:
- Search the graph before starting work and before adding nodes
- Add discoveries, decisions, key files, notable outputs, and new terms as they emerge
- Link related concepts when connections are found
- Learn from long files and outputs via bulk extraction
- Tag sessions to track work context across conversations
- Remind with actions for deferred tasks (shell commands or headless agent wakeups)
Actionable Reminders
Reminders can carry shell commands, natural-language instructions, or a headless
agent wakeup. When due, the daemon executes them automatically — simple commands
run directly, complex Claude tasks launch claude -p, Codex wakeups run
codex exec, and OpenCode wakeups run opencode run. Wakeups can resume a
known host session id, or last for the latest session when the host supports
that. This starts/resumes a headless turn from Kindex's daemon/cron context; it
does not interrupt an idle TUI unless the host itself exposes a same-thread
automation/server wake path. A Stop hook guard can block Claude from exiting when
actionable reminders are pending, but it is opt-in because Claude displays
visible "Blocked by hook" output when a Stop hook blocks.
Important boundary: remind_create records the reminder. Something must later
run kin remind check, kin remind exec, kin cron, or an installed
kin setup-cron schedule for due reminders to fire. Wake reminders are a
Kindex capability for Codex and OpenCode because those clients expose
headless commands; they are not a reentrant scheduler for an already-idle
interactive session.
Hook-time reminder injection uses a scoped reminder board. When a client supplies a chat/session id (conversation_id, chat_id, session_id, CLAUDE_SESSION_ID, CODEX_SESSION_ID, OPENCODE_SESSION_ID, CURSOR_SESSION_ID, etc.), Kindex injects only reminders scoped to that id plus reminders explicitly marked --scope global. Legacy unscoped reminders still work for manual kin prompt-check, daemon checks, and notifications, but they are not injected into an identified chat by default.
Dream — Knowledge Consolidation
Kindex can run fuzzy deduplication, auto-apply high-confidence pending suggestions, and stage bounded domain-link proposals for review. Resolved fuzzy matches are not recreated. The pending domain-review queue is capped per graph (reminders.dream_max_domain_link_suggestions, 50 by default), proposals are round-robin across domains, and rejected pairs stay rejected. The setting lives under reminders because scheduled and Stop-hook Dream runs use the reminder/maintenance configuration. Shared domains are never materialized directly as semantic edges. Like memory consolidation during sleep — replay important paths and prune noise without turning tags into topology.
Default triggers are manual CLI, periodic cron (step 11 of kin cron), and a throttled detached Stop hook. File locking prevents concurrent cycles, and reminders.dream_min_interval prevents hooks or cron from relaunching dream repeatedly after a recent start. Set reminders.dream_on_stop_enabled: false to disable Stop-time detached dream while leaving manual and cron dream available.
Conversation Modes
Modes are reusable conversation-priming artifacts that induce a processing mode in an AI session. Based on research showing that induced understanding outperforms direct instruction by 5.4x, and that 15 tokens of mode-setting capture 98.8% of achievable priming benefit.
Five built-in modes: collaborate, code, create, research, chat. Create custom modes from any session and export them for team sharing (PII-free).
Modes are not instructions — they're state inductions. A primer establishes how to think, a boundary defines what quality means, and permissions state what's allowed. The AI shifts processing mode rather than following a checklist.
Quick Start
Trust, Capture Review, and Bounded Resume
Kindex keeps automatic extraction separate from durable knowledge. The pre-compact hook stages review candidates; it does not create graph nodes or edges. Inspect and resolve candidates explicitly:
The review token detects changes between show and accept. It is not authentication, authorization, or proof of reviewer identity. Candidate source text is retained only as a SHA-256 digest, and accepted, rejected, or expired candidates are reduced to minimal receipts. Human candidate output is visibly delimited because its content is untrusted.
Verification is also explicit and records asserted local audit text:
Trusted-only search/context and kin tag resume admit only active, explicitly
verified, currently valid, non-contradicted knowledge. Resume output includes an
authority warning and machine-reason omission counts. Its legacy --tokens
option is an exact UTF-8 byte budget by default; direct library callers can pass
a provider's exact token counter when they require a provider-token guarantee.
Non-positive resume budgets return no output.
Referent Binding and Verifiable Staleness
A node can bind the external thing its claim describes — a file, URL, or repo
state — with a content digest and two clocks: asserted_at (when the claim was
made) and true_of (when the referent was observed in the digested state).
Staleness then stops being a heuristic and becomes a measurement:
Detection never deletes or rewrites content: a stale claim stays recallable,
visibly marked [stale-referent] in search and context output, and drops out
of --trusted-only projections until re-verified. URL and repo-scope bindings
are recorded with explicit digests (--referent-digest) and surfaced but never
auto-fetched.
Kindex also snapshots the SQLite store (rotating, ten per database) before any
automated destructive merge, so a false graph_merge or dream-cycle merge is
recoverable — see the human guide's restore section.
Automatic candidates expire after seven days by default. Configure a positive retention period in global or project config:
Grounded Retrieval — When the Graph Knows Nothing
Vector search returns the nearest neighbours for any query, however unrelated. Without a floor a near-null question still pulls real nodes into an agent's context, and the graph can never say "I don't know."
Kindex calibrates a similarity floor against your own corpus and reports a verdict with every result set:
The floor is never a config value. It is an immutable, versioned record keyed
by provider:model that carries the corpus it was measured against — node
count, embedding count, sample size, timestamp — so a floor calibrated when 2%
of your graph was embedded is detected as stale rather than silently trusted.
Config holds only the policy:
Verdicts are grounded, weak, ungrounded, and uncalibrated — the last
kept deliberately distinct, because "we have no yardstick" is a different fact
from "we measured and found nothing."
Shadow mode is the default on purpose. Enforcing turns a visible,
self-correcting problem (irrelevant results in context) into a silent one (an
agent proceeding without knowledge that was actually there). Run it in shadow
first, see what it would have dropped, then set enforce: true.
Multi-Hop Reach
Graph expansion honours --hops, with per-hop score decay and a mandatory
beam. The beam's ordering is total and stable, so traversal is reproducible:
adding an edge elsewhere in a hub's neighbourhood cannot silently change what a
query returns.
Extraction Engines
Extraction is an input, never an authority. Engine output lands in the
capture_candidates quarantine and never writes nodes or edges directly.
The gate is two-part: grounding precision is a floor (don't invent), title recall is the discriminator (actually find what a curator would record). Either alone is gameable — an engine that only copies verbatim scores perfect grounding while finding nothing.
An optional LLM-free deterministic engine is available behind an extra:
It is excluded from kindex[all] by design, and degrades to keyword extraction
with a warning when absent. Measure it with kin extract eval before enabling
it; an engine that cannot beat regexes on your corpus has not earned the
install size.
Editing & Superseding
Knowledge changes. Kindex edits are policy-aware: each node type has a mutability class that says how its content may change, so facts stay correctable while history-bearing records stay append-only.
| Class | Node types | What's allowed |
|---|---|---|
editable | concept, document, artifact, skill, person, project, question | Full in-place edit: title, content, append, tags, intent, expires |
additive | decision, constraint, directive, checkpoint, watch | History matters — append and expires only; use supersede to replace |
managed | task, session, coordination | Refused — use the dedicated task/tag/coord commands |
Every edit logs per-field value diffs to the activity log, and kin changelog renders them:
Edits re-embed the node for vector search, protect reserved operational state (locks, claims, coordination messages), and refuse to modify a node another agent has locked unless you pass --force. The per-type class can be overridden in config with edit_policy: {document: additive} if your team wants stricter history.
Profiles
One machine, multiple sequestered graphs. Profiles map names to separate data directories so work and personal knowledge never mix — different DBs, different embeddings, different everything.
Resolution order (first match wins):
--profile <name>flagKIN_PROFILEenvironment variableprofile:key from the project's.kin/configchain- Longest-prefix match of the current directory against profile
roots default_profile- Legacy single graph — no profiles configured means nothing changes
Register the existing legacy graph (usually ~/.kindex) as the default profile before creating others: once a default profile exists, sessions outside all roots route to it, and an unregistered legacy graph stops receiving cron maintenance (kin profile create warns when this would happen).
Stamp guard. Each profile's database is stamped with its profile name on first open. Opening a stamped database under a different profile raises an error instead of silently mixing graphs — a wrong --data-dir can't cross-contaminate.
MCP note. The MCP server binds its profile once at process start and keeps it for the process lifetime. To switch profiles for an agent, restart its MCP server (or run a second server with KIN_PROFILE set in its environment).
kin cron runs one maintenance pass per profile and routes session ingestion by roots — sessions whose cwd falls under a profile's roots land in that profile's graph; the default profile takes the unmatched remainder. With no default_profile, a final legacy-remainder pass ingests the unmatched sessions into the legacy graph and keeps its maintenance (reminders, decay, dream) running. kin cron --profile X pins a single pass and keeps routing active — it only ingests the sessions X owns; a bare --data-dir with no resolved profile runs a legacy take-everything pass on exactly that directory. Routing also applies to kin ingest sessions|codex-sessions, the MCP ingest tool, and kin watch. An explicit --data-dir that overrides a profile's data_dir never stamps an unstamped database with the active profile.
Collab
Multiple agents working the same graph can coordinate through conversations with members, read cursors, shared resources, advisory locks, and standing inject messages.
Agent identity resolves as KIN_AGENT_ID env > agent_id in config > user@shorthost. kin whoami shows both the user and the resolved agent id. Locks, claims, cursors, and message targeting all key off this identity.
Members see their collabs in the session-start prime block:
New targeted/broadcast messages and standing injects also surface mid-session through the prompt hook (with a cooldown so they don't nag). Display is configurable:
Locks are advisory and expire — an expired lock never blocks anyone, and the cron pass sweeps stale locks, conversations, and task claims.
.kin/ Directory & Inheritance
Projects use .kin/ directories that encode their communication style, engineering standards, and values. Teams inherit from orgs. Repos inherit from teams. The knowledge graph carries the voice forward.
The .kin/ directory is the standard location for all kindex project artifacts:
.kin/config— project metadata (voice, domains, audience, inheritance).kin/index.json— graph snapshot for git tracking.kin/code-map.json— repo-relative code map generated bykin export code-map.kin/.gitignore— ignores local-only runtime state under.kin/local,.kin/cache,.kin/tmp, and.kin/private
These files are meant to ship with the code. Do not ignore the whole .kin/
directory in project .gitignore; ignore only local/private subdirectories.
Kindex resolves project config from --project-path, then KIN_PROJECT, then
the git worktree root, then the current directory. User config still lives in
~/.config/kindex/kin.yaml and deep-merges below project config, so user
preferences remain local while the repo's work contract travels with the repo.
Generated .kin/ snapshots use canonical, id-keyed ordering and omit volatile
timestamps so repeated exports of unchanged source do not churn Git diffs.
Concurrent branches merge them without manual conflicts via a structured merge
driver that kin index registers automatically on first run (or kin setup-merge
to (re)install it in a fresh clone). .kin/index.json is then unioned by node id
(newer updated_at wins) and .kin/code-map.json by node/edge/layer — lossless
across machines (regenerating from one machine's local DB would drop the other
branch's nodes), with output byte-identical to a fresh kin index. kin merge-kin
is the driver git invokes; repos without it registered fall back to git's default
merge. Never hand-resolve a generated .kin snapshot.
Tracked .kin artifacts must be self-contained and machine-portable: code-map
paths are repo-relative POSIX paths, and task/report metadata must not point at
$HOME, /Users/..., /tmp/..., or another developer-local filesystem
location. If a scanner report is needed as evidence for future work, ship a
repo-local subset or a durable shared artifact rather than a local pointer.
kin export code-map is different from the normal graph export: it projects
current code structure into a small dashboard- and agent-friendly graph of
files, classes, functions, layers, and code dependencies. Use it when a tool
needs the repo's code shape, not the full Kindex knowledge graph.
| Export | Contains | Use case |
|---|---|---|
kin export | Audience-scoped Kindex nodes, edges, provenance, and graph metadata | Backup, exchange, or graph-level tooling |
kin export code-map | Current repo code structure, code dependencies, layers, and repo-relative file paths | Dashboards, code navigation, and agent tooling |
For code-map output, src/file.py is portable; /Users/alice/repo/src/file.py
and C:\repo\src\file.py are not.
Code-map path requirements:
- Output always uses repo-relative POSIX paths, even when the source machine is Windows.
- Absolute provenance is normalized only when it resolves inside the requested repo root.
- Outside-root, malformed, or unresolved paths are omitted with a safe warning rather than leaked into the artifact.
- Archived nodes are excluded by default because the tracked artifact describes
current code; API callers can opt into
include_archived=Truefor historical analysis.
The payments service gets Acme's voice principles, the platform's engineering standards, AND its own domain context. Local values override ancestors. Lists merge with dedup. Parent directories auto-walk when no explicit inherits is set.
Old-style .kin files (plain YAML) are auto-upgraded to .kin/config on first access.
See examples/kin-voices/ for ready-to-use voice templates.
Architecture
Node Types
Knowledge: concept, document, session, person, project, decision, question, artifact, skill
Code Intelligence
Ingest repository structure with kin ingest code --directory .:
- Module nodes (artifact) — one per source file with structural summary: classes, public functions, signatures, imports
- Symbol nodes (concept) — one per class/interface/type with method signatures
- Edges — imports (
depends_on), inheritance (implements), containment (context_of), call graph (relates_to) - Three extraction tiers — ctags (100+ languages), cscope (C/C++ cross-refs), tree-sitter (AST call graphs)
- Resilient fallback — unsupported or untagged files still become module nodes; available tree-sitter parsers can still enrich those modules, with fallback provenance retained in metadata
- Incremental — file hashing skips unchanged files on re-ingest
- Unity projects (opt-in) —
--unity(orcode_ingest: {unity: true}in.kin/config) indexes serialized assets (.unity,.prefab,.asset,.mat,.controller,.anim), sniffs text-vs-binary serialization, and attaches each asset's.metaGUID so models can resolve GUID-based references;code_ingest.include_extensionsmaps further extensions (e.g..shader: Unity Shader)
Code structure lives in the same graph as your decisions, watches, and constraints. Search finds both what calls a function and what broke last time someone changed it.
Operational: constraint (invariants), directive (soft rules), checkpoint (pre-flight), watch (attention flags)
CLI Reference (70+ commands)
Core
| Command | Description |
|---|---|
kin search <query> | Hybrid FTS5 + graph search with RRF merging (--tags, --mine, --trusted-only) |
kin context | Formatted context block for AI injection (--level, --tokens, --trusted-only) |
kin add <text> | Quick capture with auto-extraction and linking (--tags, --type) |
kin show <id> | Full node details with edges, provenance, and state |
kin list | List nodes (--type, --status, --tags, --audience, --mine, --limit) |
kin ask <question> | Question classification + LLM or context answer |
Knowledge Management
| Command | Description |
|---|---|
kin learn | Extract knowledge from sessions and inbox |
kin link <a> <b> | Create weighted edge between nodes |
kin edit <id> | Policy-aware in-place edit (--title, --content, --append, --add-tags, --expires) |
kin supersede <id> <text> | Replace a node with a new one, preserving history (--reason) |
kin alias <id> [add|remove|list] | Manage AKA/synonyms for a node |
kin register <id> <path> | Associate a file path with a node |
kin orphans | Semantic nodes with no semantic connections (sessions excluded) |
kin trail <id> | Temporal history and provenance chain |
kin decay | Apply weight decay to stale nodes/edges |
kin recent | Recently active nodes |
kin tag [action] | Session tags: start, update, segment, pause, end, resume, list, show |
kin archive [action] | Search, restore, or run the reversible slow-graph archive |
kin candidate [action] | Quarantined capture review: list, show, accept, reject, prune, erase |
kin verify <node> | Assert verification and optional RFC 3339 valid interval |
kin invalidate <node> | Record asserted invalidation actor, code, and exclusive end time |
kin stale | Re-hash referent-bound nodes; demote stale ones from trusted recall (--rebind) |
kin remind [action] | Reminders: create, list, show, snooze, done, cancel, check, exec |
kin mode [action] | Conversation modes: activate, list, show, create, export, import, seed |
Graph Analytics
| Command | Description |
|---|---|
kin graph [mode] | Dashboard: stats, centrality, communities, bridges, trailheads |
kin suggest | Bridge opportunity suggestions (--accept, --reject) |
kin skills [person] | Skill profile and expertise for a person |
kin embed | Index nodes for vector similarity search |
kin embed plan/enqueue/reindex/drain/status | Scoped embedding maintenance for full or gradual reindexing |
embedding.provider: voyage uses voyage-context-4 by default. When the
configured model supports contextual chunk embeddings, Kindex stores stable
overlapping chunk vectors and aggregates chunk hits back to the parent node. Use
kin embed plan --stale --kin ./path/.kin to estimate a targeted update,
kin embed enqueue --stale --tags mea to trickle selected work through cron, or
kin embed reindex --target ./repo --limit 100 for a bounded foreground pass.
Unsupported providers/models keep the single-vector strategy unless they later
gain explicit contextual support.
Operational
| Command | Description |
|---|---|
kin status | Graph health + operational summary (--trigger, --owner, --mine) |
kin set-audience <id> <scope> | Set privacy scope (private/team/org/public) |
kin set-state <id> <key> <value> | Set mutable state on directives/watches |
kin export | Audience-aware graph export with PII stripping |
kin export code-map | Repo-relative code map for dashboards, code navigation, and agent tooling |
kin import <file> | Import nodes/edges from JSON/JSONL (--mode merge/replace) |
kin sync-links | Update node content with connection references |
Collab & Multi-Agent
| Command | Description |
|---|---|
kin coord [action] | Agent coordination: start, post, read, list, end, join, attach, inject |
kin lock <id> | Acquire an advisory lock on a node (--ttl, --note, --force) |
kin unlock <id> | Release an advisory lock (--force for foreign locks) |
kin profile [action] | Named graph profiles: list, which, create |
Ingestion & External Sources
| Command | Description |
|---|---|
kin ingest <source> | Ingest from: projects, sessions, codex-sessions, files, commits, github, linear, code, all |
kin cron | One-shot maintenance cycle (for crontab/launchd) |
kin dream | Knowledge consolidation: dedup and reviewable link proposals (--deep, --detach) |
kin watch | Watch for new sessions and ingest them (--interval) |
kin analytics | Archive session analytics and activity heatmap |
kin index | Write .kin/index.json for git tracking |
kin merge-kin | Git merge driver: structured union merge of .kin artifacts (invoked by git) |
Infrastructure
| Command | Description |
|---|---|
kin init | Initialize data directory |
kin config [show|get|set] | View or edit configuration |
kin agent-config [show|set] | View or tune per-client/per-instance agent behavior overrides |
kin policy [show|check] | Show or enforce project work policy from .kin/config |
kin setup-merge | Register the .kin structured merge driver in the current git repo |
kin setup-hooks | Install lifecycle hooks into Claude Code |
kin setup-codex-hooks | Install prompt-time attention hook into Codex |
kin setup-codex-mcp | Install kindex MCP server into Codex |
kin setup-gemini-mcp | Install kindex MCP server into Gemini CLI |
kin setup-antigravity-mcp | Install kindex MCP server into Google Antigravity |
kin setup-antigravity-hooks | Install lifecycle hooks into Google Antigravity |
kin setup-opencode-mcp | Install kindex MCP server into OpenCode |
kin setup-cursor-mcp | Install kindex MCP server into Cursor |
kin setup-cron | Install periodic maintenance + dedicated reminder-check job (launchd/crontab) |
kin setup-claude-md | Output/install recommended CLAUDE.md kindex directives |
kin setup-agents-md | Output/install recommended AGENTS.md kindex directives (Codex, OpenCode) |
kin setup-gemini-md | Output/install recommended GEMINI.md kindex directives |
kin setup-antigravity-md | Output/install Antigravity/GEMINI.md kindex directives |
kin setup-cursor-rules | Output/install recommended Cursor rule (.mdc) for kindex |
kin stop-guard | Stop hook guard for actionable reminders |
kin doctor | Health check with graph enforcement (--fix) |
kin migrate | Import markdown topics into SQLite |
kin budget | LLM spend tracking |
kin attention | Toggle/check/estimate conversation-attention reminder injection |
kin attention-hook | Advisory attention hook for prompt/tool events |
kin whoami | Show current user identity |
kin changelog | What changed (--since, --days, --actor) |
kin log | Recent activity log |
kin git-hook [install|uninstall] | Manage git hooks in a repository |
kin prime | Generate context for SessionStart hook (--codebook) |
kin compact-hook | Pre-compact knowledge capture |
Configuration
Config is layered like git — global defaults, then global config, then local config. Each layer deep-merges over the previous, so you only set what you want to override.
| Layer | Path | Purpose |
|---|---|---|
| Global | ~/.config/kindex/kin.yaml | User-wide defaults |
| Local | .kin/config or kin.yaml at project root | Project-specific overrides shipped with code |
Use kin config set --global llm.enabled true for global settings, or kin config set llm.model claude-sonnet-4-6 for project-local. Use --project-path /path/to/repo or KIN_PROJECT=/path/to/repo when running from outside the repo.
Agent-facing behavior can be tuned at three levels:
agent-config writes only approved behavior keys such as attention.*,
sim.*, collab.prompt_cooldown_minutes, and hooks.prime_tokens; it cannot
change storage paths or arbitrary config. Agents should propose these changes
through their normal tool/command permission flow. Antigravity hooks force a user
permission prompt before kin config set or kin agent-config set runs.
Use kin attention estimate --messages 1000 to estimate cost over a fixed prompt window. Conversation accounting is retained when a client provides a stable session id. Hook-driven attention does not fall back to cwd as a fake conversation id, because that would cross-pollute two chats open in the same repo.
Development
License
MIT