Skip to content
Back to search

keep

Open-source memory and knowledge for AI agents, written in Rust

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 21 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/TulipFarm/keep 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/TulipFarm/keep'

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/tulipfarm--keep/badge.svg)](/listings/tulipfarm--keep)

HTML

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

Install

i

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.

curl -fsSL https://keep.tulipfarm.ai/install.sh | sh

The script asks which local database to use (in memory, Postgres + pgvector, or Postgres + Qdrant), builds Keep and connects Claude Code, Codex and Copilot CLI. Prefer to let your agent do it? Tell it: `Install https://keep.tulipfarm.ai/install.md`. For a container, use `ghcr.io/tulipfarm/keep`. See [Connecting coding agents](#connecting-coding-agents) for the manual steps.

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 · 189 lines · 1 finding marked
  1. <p align="center">
  2. <a href="https://keep.tulipfarm.ai"><img src="docs/assets/banner.svg" alt="Keep: memory your agents can't quietly rewrite" width="100%"></a>
  3. </p>
  4. <p align="center">
  5. <a href="https://github.com/TulipFarm/keep/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/TulipFarm/keep/ci.yml?branch=main&label=CI&style=flat-square"></a>
  6. <a href="https://github.com/TulipFarm/keep/actions/workflows/image.yml"><img alt="Image" src="https://img.shields.io/github/actions/workflow/status/TulipFarm/keep/image.yml?branch=main&label=image&style=flat-square"></a>
  7. <a href="LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/badge/license-Apache--2.0-0a0a0a?style=flat-square"></a>
  8. <img alt="Written in Rust" src="https://img.shields.io/badge/written%20in-Rust-dea584?style=flat-square&logo=rust&logoColor=white">
  9. <img alt="MCP server" src="https://img.shields.io/badge/MCP-server-0a0a0a?style=flat-square">
  10. <img alt="Status: research preview" src="https://img.shields.io/badge/status-research%20preview-e5311d?style=flat-square">
  11. <a href="https://github.com/TulipFarm/keep/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/TulipFarm/keep?style=flat-square&logo=github"></a>
  12. </p>
  13. <p align="center">
  14. <a href="https://keep.tulipfarm.ai"><b>Website</b></a> ·
  15. <a href="docs/server.md">Docs</a> ·
  16. <a href="https://github.com/TulipFarm/keep">GitHub</a> ·
  17. <a href="https://github.com/TulipFarm/keep/issues">Issues</a> ·
  18. <a href="https://tulipfarm.ai">TulipFarm</a>
  19. </p>
  20. # Keep
  21. Keep is an open-source memory and knowledge system for AI agents, written in
  22. Rust. It is built around two primitives:
  23. - **Memory files** — small, curated Markdown files an agent reads at the start
  24. of every session (preferences, standing instructions, project conventions).
  25. Every change is a revision, so memory can be reviewed, diffed and rolled back.
  26. - **Knowledge** — an append-only record of what happened (episodes) and the
  27. facts derived from it, searchable on demand. Facts keep their provenance and
  28. validity over time instead of being silently overwritten.
  29. ## Quick start
  30. ```sh
  31. curl -fsSL https://keep.tulipfarm.ai/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 38 on GitHub
  32. ```
  33. The script asks which local database to use (in memory, Postgres + pgvector,
  34. or Postgres + Qdrant), builds Keep and connects Claude Code, Codex and Copilot
  35. CLI. Prefer to let your agent do it? Tell it:
  36. `Install https://keep.tulipfarm.ai/install.md`. For a container, use
  37. `ghcr.io/tulipfarm/keep`. See [Connecting coding agents](#connecting-coding-agents)
  38. for the manual steps.
  39. ## Status: research first
  40. Keep is at the very start. Before building the engine, we are building the
  41. benchmark harness that will decide whether it is worth building: a
  42. preregistered, reproducible way to compare Keep against simple baselines
  43. (full context, BM25, dense retrieval, plain notes) on public long-term memory
  44. benchmarks. If Keep does not beat those baselines, we will say so.
  45. What exists today:
  46. | Crate | Purpose |
  47. | --- | --- |
  48. | `keep-core` | Domain types for Memory files, revisions, episodes and facts; content hashing |
  49. | `keep-providers` | Chat, embedding and tokenizer traits; deterministic mock providers; an OpenAI-compatible client that refuses to dispatch unless explicitly allowed; budget caps |
  50. | `keep-store` | Lexical (BM25) and vector index contracts with in-memory implementations |
  51. | `keep-postgres` | pgvector adapter |
  52. | `keep-qdrant` | Qdrant adapter |
  53. | `keep-memory` | The Memory primitive: lossless Markdown entries, revisions, compare-and-swap edits, trash, undo, forget, context assembly, export and import |
  54. | `keep-ledger` | Postgres storage for Memory, with its own migrations |
  55. | `keep-knowledge` | The Knowledge primitive: bi-temporal facts with evidence, hybrid search, a permission-safe book index and forgetting. See [docs/knowledge.md](docs/knowledge.md) |
  56. | `keep-bench` | The benchmark harness library and `keep-bench` CLI |
  57. | `keep-server` | The `keep` binary: Memory and Knowledge for coding agents over MCP (stdio) and HTTP. See [docs/server.md](docs/server.md) |
  58. Every Keep ablation arm runs in the harness: Memory only (`keep-m*`),
  59. Knowledge only (K0, K1) and both together (Mk0, Mk1). See
  60. [docs/memory.md](docs/memory.md) for how Memory works.
  61. ## Running the harness
  62. Requires Rust (the pinned toolchain in `rust-toolchain.toml` installs
  63. automatically through rustup) and, optionally, Docker.
  64. ```sh
  65. cargo test --workspace # unit and integration tests, offline
  66. cargo run -p keep-bench -- dry-run fixtures/manifests/longmemeval-mock.toml
  67. cargo run -p keep-bench -- run fixtures/manifests/longmemeval-mock.toml
  68. cargo run -p keep-bench -- run fixtures/manifests/longmemeval-memory-mock.toml
  69. cargo run -p keep-bench -- run fixtures/manifests/ablation-mock.toml
  70. cargo run -p keep-bench -- report results/<run-id>
  71. ```
  72. Everything above runs offline with mock models and synthetic fixtures. Mock
  73. output measures the plumbing, not memory quality: never quote it as a result.
  74. Real benchmark data is downloaded separately and never committed:
  75. ```sh
  76. scripts/fetch-datasets.sh # LoCoMo, LongMemEval-S, oracle → data/
  77. cargo run --release -p keep-bench -- dry-run manifests/longmemeval-s-dev.toml
  78. ```
  79. The manifests in `manifests/` are templates: model pins are placeholders and
  80. budget caps are zero, so they cannot call a model until someone fills them in
  81. deliberately. Remote model calls need `dispatch.allow_model_calls = true` in
  82. the manifest **and** `--allow-model-calls` on the command line.
  83. For development without API keys, `manifests/dev/` runs answer and judge
  84. calls through a locally installed, signed-in GitHub Copilot CLI and embeds
  85. with a pinned local ONNX model:
  86. ```sh
  87. cargo run --release -p keep-bench --features local-embeddings -- \
  88. dry-run manifests/dev/locomo-copilot-dev.toml
  89. cargo run --release -p keep-bench --features local-embeddings -- \
  90. run manifests/dev/locomo-copilot-dev.toml --allow-model-calls
  91. ```
  92. These runs are **non-canonical**: the CLI adds its own hidden system prompt
  93. and does not pin the upstream model. Every artifact is stamped as such, the
  94. run stops at the manifest's AI-credit cap, and `keep-bench compare` refuses
  95. them unless `--allow-non-canonical` asks for an internal comparison, whose
  96. every output is stamped INTERNAL / NON-CANONICAL. See the methodology for
  97. details.
  98. The canonical G0 manifests in `manifests/g0/` pin gpt-4o-mini (answers) and
  99. gpt-4o (judge) served by Azure OpenAI. `scripts/run-g0.sh` checks the
  100. credentials file, prints the dry-run estimate and runs them after
  101. confirmation; see [docs/benchmarks/running-g0.md](docs/benchmarks/running-g0.md).
  102. `scripts/run-g0-copilot.sh` defaults to the v5 Copilot CLI experiments
  103. (`manifests/g0/*-copilot-v5.toml`) as an internal, non-canonical check.
  104. Set `KEEP_G0_VERSION=1`, `2`, `3` or `4` to reproduce an earlier version,
  105. `6` for the v6 experiments (answer-v6 working notes and consistent
  106. judge verdicts), or `7` for the v7 experiments (answer-v7 world-knowledge
  107. bridging and specific wording).
  108. G2 is the gate-eligible run. `manifests/g2/` compares keep-mk7 with
  109. full-context-v7 and dense-6k-v7 (keep-mk6 is reported, not gated), with
  110. three seeds on both storage profiles against one pinned Azure `gpt-6-luna`
  111. deployment, and has separate sealed-holdout confirmation manifests. The
  112. `-v2` manifests (`scripts/run-g2-azure.sh --set v2`) swap the candidate
  113. for keep-mk8 and report keep-mk7.
  114. `scripts/run-g2-azure.sh` requires a dry-run estimate and a `--max-usd` cap;
  115. see [docs/benchmarks/running-g2.md](docs/benchmarks/running-g2.md).
  116. Local storage backends for the two storage profiles:
  117. ```sh
  118. docker compose --profile postgres-vector up -d # Postgres + pgvector on 127.0.0.1:15433
  119. docker compose --profile postgres-qdrant up -d # adds Qdrant on 127.0.0.1:16333
  120. ```
  121. To run the Keep server itself with either profile, generated secrets and
  122. health-gated start-up, use `deploy/compose.yaml`; see
  123. [Run with Docker Compose](docs/server.md#run-with-docker-compose).
  124. ## Connecting coding agents
  125. `keep mcp` serves Memory and Knowledge to Claude Code, Codex, Copilot CLI and
  126. other MCP clients; `keep serve` exposes the same tools over HTTP on
  127. `127.0.0.1`. Agents that use the same project share one memory. The
  128. recommended setup is one `keep serve` daemon, with every agent connected
  129. through `keep mcp --server`:
  130. ```sh
  131. cargo install --path crates/keep-server --features local-embeddings
  132. keep --user me serve & # the daemon
  133. keep --project my-app mcp --server http://127.0.0.1:7357 # in each agent
  134. ```
  135. The daemon can hold Memory in memory or in Postgres, embeds Knowledge with
  136. a local ONNX model (no hosted model API unless you configure an
  137. OpenAI-compatible model for fact extraction and summaries), and supports
  138. scoped tokens, TLS, per-caller evidence budgets and per-source read
  139. allowlists. A container image is published at `ghcr.io/tulipfarm/keep`.
  140. [docs/server.md](docs/server.md) covers storage, scopes, the tool list,
  141. security and copy-paste client configuration.
  142. See [docs/benchmarks/methodology.md](docs/benchmarks/methodology.md) for how
  143. runs are designed, what the numbers mean and what they cannot tell you.
  144. ## Links
  145. - Website: <https://keep.tulipfarm.ai>
  146. - Source: <https://github.com/TulipFarm/keep>
  147. - Docs: [Server](docs/server.md), [Memory](docs/memory.md), [Knowledge](docs/knowledge.md), [Benchmark methodology](docs/benchmarks/methodology.md)
  148. - Built by [TulipFarm](https://tulipfarm.ai)
  149. ## Licence
  150. Apache-2.0. See [LICENSE](LICENSE). Benchmark datasets have their own
  151. licences (LoCoMo is CC BY-NC 4.0); the harness downloads them for local
  152. evaluation only.

Ratings and comments

Sign in to rate this skill.

Sign in

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