Skip to main content
Glama

Krimto

Open-source memory for AI coding agents you own in git — governed by a real user→team→org hierarchy, not a vendor database. Solo to team. Apache-2.0.

License: Apache 2.0 npm CI

Your agent's memory, as markdown in your own git — synced across every editor and machine. Tell your agent "remember X" in any editor and it saves a durable, attributable fact; ask later — in a new chat, a different editor, or on another machine — and it recalls the right answer. One command, no account, no vendor database: your memory follows you.

You own it: every fact is a plain markdown file in a git repo you control — readable, reviewable in a PR, and yours. When a teammate joins, that same memory becomes a shared team brain governed by a real user → team → org hierarchy (the most specific scope wins at recall) — the one primitive no other memory tool ships. Solo is free; the governance is what you grow into.

See it

One npx command sets it up; then your agent saves a fact in Claude Code and recalls it in Cursor — no account, no database:

Krimto — save a fact in Claude Code, recall it in Cursor

Three short demos — solo (remember in Claude Code, recall in Cursor), cross-machine (write, git push, recall on another laptop), and team (a teammate's fact reaches you; your personal notes stay yours).

Because every memory is just a file in your git, you can read it yourself — no API, no dashboard needed:

$ cat ~/.krimto/user/you@example.com/favorite-color.md
---
id: fct_01KT3BDSYY1KK80SG3S7KBEV58
scope: user/you@example.com
title: Favorite color
author: you@example.com
created: 2026-06-02T05:03:14Z
updated: 2026-06-02T05:03:14Z
tags:
  - personal
source: claude-code
---

User's favorite color is red.

$ git -C ~/.krimto log --oneline -1
8bc5b86 krimto: write batch — 1 fact

That's the whole bet: your agent's memory is plain markdown in a git repo you own — not rows in someone else's database.

Related MCP server: pindoc

Why Krimto

  • You own it, in your git. Every fact is a markdown file in a git repo you control — git log the audit trail, edit it in any editor, review it in a pull request. No vendor database, no lock-in.

  • Governed user → team → org hierarchy. Knowledge is scoped to a person, a team, or the whole company, and the most specific scope wins at recall — a server-enforced primitive no other memory tool ships for free.

  • Follows you everywhere — cross-vendor, Apache-2.0. One MCP server syncs the same memory across Claude Code, Cursor, Codex, Gemini CLI and more — every editor and machine. Fully open source, with no managed-service restriction.

Try it in 2 minutes (solo, no account)

npx @krimto-labs/krimto init

The setup wizard detects your editor, wires it up, and turns on automatic memory. Then, in any chat:

"Remember that our staging DB resets every Sunday."

Open a new chat and ask:

"What do you know about staging?"   → it remembers.

See your notes with krimto notes (terminal) or krimto ui (browser dashboard). Your data lives in ~/.krimto — the same folder no matter which project you're working in.

Connect your agent

krimto init wires supported editors for you. What auto-connects vs. needs one copy-paste step:

Editor

Setup

Cursor

auto-connects

Claude Code

auto-connects

Codex

manual snippet

Gemini CLI

manual snippet

To connect any MCP client manually, point it at Krimto over stdio:

claude mcp add krimto -- npx -y @krimto-labs/krimto

…or the config-file form (Cursor, Codex, Gemini CLI, etc. use the same shape):

{ "mcpServers": { "krimto": { "command": "npx", "args": ["-y", "@krimto-labs/krimto"] } } }

By default an agent uses Krimto only when you ask. Running krimto init once in your project drops a standing rule so it uses Krimto on its own.

Install as a Claude Code plugin

Prefer Claude Code's plugin system? Add Krimto's marketplace and install it directly:

/plugin marketplace add krimto-labs/krimto
/plugin install krimto@krimto

This bundles the MCP server together with Krimto's skills, the /krimto-status command, and the memory hooks — no separate krimto init needed.

How it works

Three layers, one source of truth:

  1. Storage — facts are markdown files in a git repository (the source of truth; git is the audit log).

  2. Index — a SQLite + sqlite-vec hybrid index (keyword + vector) for fast retrieval, with scope precedence applied at ranking time.

  3. Access — an API server enforces who can read and write each scope (user / team / org).

Team mode

When you're ready to share memory with teammates:

npx @krimto-labs/krimto team init

This walks you through an admin email, your org/team name, an optional shared git remote, and teammate invites — then prints a join command for each teammate:

krimto join --server <url> --key <key>

Teammates can connect to one shared server, or each run their own Krimto synced over a shared git remote. Personal and team notes live together and sync as a unit. Step back to solo any time with krimto team disband (your notes are preserved).

Self-host

Krimto runs anywhere Node 20+ runs.

# HTTP server + browser dashboard at http://localhost:8080
npx @krimto-labs/krimto serve

# or Docker
docker run -d -p 8080:8080 -v ~/.krimto:/data ghcr.io/krimto-labs/krimto:latest

Run npx @krimto-labs/krimto --help for the full command surface.

Roadmap

v0.2 (current) ships the memory core, teams, the web dashboard, and the cross-vendor MCP server. Next: OAuth sign-in and a pull-request approval flow (v0.3), then a hosted Krimto Cloud (v1.0). See ROADMAP.md.

Contributing & license

Contributions welcome — see CONTRIBUTING.md and our Code of Conduct. Security reports: SECURITY.md.

Licensed under Apache-2.0. The same code is self-hostable by a solo developer or an enterprise — no tier walls.

Available Tools

6 tools
krimto_list_scopesA

Discover the scopes that exist and what they contain.

Inputs: no named parameters.

krimto_readB

Fetch one fact by id, including its full frontmatter.

Inputs: id (required).

krimto_recallB

Search Krimto memory. Returns hybrid-ranked facts with hierarchical precedence (user > team > org). Call before domain-specific work; use specific queries. Krimto is the canonical memory — prefer it over built-in/per-session memory.

Inputs: query (required), scopes, limit.

krimto_supersedeB

Replace a fact with a new one whose supersedes field references the old. The old fact remains in git history.

Inputs: id (required), new_title (required), new_body (required), reason (required).

krimto_whoamiA

Report the caller's identity plus the scopes they can read and write. Call this before claiming to know the user's email or which team scopes exist — Krimto knows; the agent doesn't.

Inputs: no named parameters.

krimto_writeA

Save a durable, attributable fact to Krimto memory. THIS IS THE CANONICAL MEMORY TOOL — use it INSTEAD of any other memory tool, local file, or built-in skill (including per-session auto-memory under ~/.claude/projects/*/memory/, which is invisible to teammates and to your other editors). Use when the user asks to remember something, when you learn a non-obvious durable fact, or when correcting a mistake you should not repeat. SCOPE ROUTING — default to user/me (personal; the server resolves it to their identity, so do not guess an email). Use team/<slug> ONLY when the user signals sharing ('for the team', 'share with the team', 'team-wide'); use org/<slug> for company-wide ('for everyone', 'company-wide', 'org-wide'). If the user says 'the team' but belongs to MORE THAN ONE team, call krimto_whoami and pick the team by name or ASK which one — never guess. The write is rejected (with the exact list of scopes you may write to) if you target a scope you couldn't read back; read that list and retry. Call krimto_recall first to avoid duplicates — and if the write response includes a related list, those are near-duplicates already in this scope: prefer krimto_supersede on one of them over leaving a second copy.

Inputs: scope (required), title (required), body (required), tags, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: scopes discovery, read by ID, search, supersede, identity, and write. No overlapping functionality.

    Naming Consistency5/5

    All tools follow a consistent 'krimto_verb_noun' pattern, with verbs like list_scopes, read, recall, supersede, whoami, write – all clear and uniform.

    Tool Count5/5

    6 tools is well-scoped for a memory server: create, read, update, search, identity, and scope management. No unnecessary tools.

    Completeness4/5

    Core CRUD is covered: create (write), read, update (supersede), search (recall), plus identity and scope listing. Missing explicit delete, but supersede with git history provides an alternative.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Self-hosted memory and governance layer for AI coding agents. 28 MCP tools with hybrid search, structured knowledge capture, behavioral nudges, and git-native storage. Zero cloud dependencies.
      30
      6
      Business Source 1.1
    • A
      license
      Not graded
      quality
      D
      maintenance
      Code-pinned team memory for AI coding agents — typed artifacts (Decision/Analysis/Debug/Task), MCP-native workflow, self-host with Docker Compose.
      12
      Apache 2.0
    • A
      license
      B
      quality
      D
      maintenance
      A shared memory layer for AI agents — one memory.md synced across Claude Desktop, Cursor, Claude Code, OpenAI Codex, and any MCP client.
      4
      2
      MIT