githippo

Claude forgets everything when the context compacts. githippo doesn't.

Long-term memory for Claude and any MCP client, stored as plain Markdown in a git repo you own. Hybrid semantic search, a knowledge graph, auto-memory and compaction survival, at about 790 tokens of tool overhead per turn. Every memory is a git commit you can read, diff and revert.

curl -fsSL https://raw.githubusercontent.com/AnxovatomicaES/githippo/main/install.sh | sh

That's the whole install: no account, no token, no questions. It sets up a local memory vault, wires Claude Code (hooks, MCP, status line) and fetches semantic search in the background. Restart Claude Code and just talk; it remembers.

Want it backed up and synced across machines? githippo sync --github creates a private repo with your existing GitHub CLI login and pushes after every change. Just curious? npx -y github:AnxovatomicaES/githippo#v3.9.3 demo shows it working in 30 seconds without installing anything.

one click → use it from claude.ai and your phone

Why another memory server?

Because each good idea out there lives in a different tool. githippo takes the best of each and fixes the part that hurts:

Version 3.1 adds the best idea from each of nine other memory tools, read in their source and credited in docs/prior-art.md: tags, compaction steering and summary capture, session diffing, activity-aware decay, a code-aware tokenizer, errors in checkpoints, an honest status line, plugin packaging and alwaysLoad registration.

What else it does:

• Compliance guard. Blocks private keys (including PGP) and API tokens (Anthropic, OpenAI, GitHub, AWS, Slack, Stripe, Google, SendGrid, npm, Hugging Face, JWTs), password and secret assignments (password: …, DB_PASSWORD=…, AWS_SECRET_ACCESS_KEY=…), connection strings with embedded passwords, card security codes, IBANs (mod-97 checked, spaces or hyphens), card numbers (Luhn checked, even with other digits beside them), Spanish DNI/NIE, French NIR (checksums), UK National Insurance numbers (written in capitals) and US SSNs *before* they become permanent git history. It reads through lookalike letters, other scripts' digits and zero-width characters, and plain prose such as "password: required", "tokens: 128000" or a Spanish date like "12/10/26" is left alone. It also catches opaque Authorization: Bearer/Basic headers, GitLab, Google OAuth, Slack and Discord webhook and bot tokens, Telegram, Twilio, Mailgun, Azure, Shopify, PyPI and DigitalOcean tokens, STRIPE_KEY=-style environment lines, PINs, and the quoted-JSON, markdown-bold and "the password is …" forms of a password. A secret that is base64-encoded, split across words or URL-encoded still gets through: it is a backstop, not DLP.
• Compaction-proof by design, three ways (see below).
• Cross-lingual recall. The default multilingual embedder runs locally; ask in Spanish, find notes written in English.
• Updates are never mistaken for duplicates. "Launch is end of Q1" and "end of Q2" embed almost identically. githippo also compares numbers, dates and names, so the update is saved, the old line is flagged, and maintain reports possible contradictions. Measured in docs/calibration.md. When each fact has a content word the other lacks ("dark" / "light", "weekly" / "monthly", "read" / "write"), they are never called duplicates either, because neither keyword overlap nor embeddings can tell a synonym from an opposite: the new fact is saved and flagged as a possible update, and maintain lists the pair as a possible contradiction. (Before this rule, half of a set of twelve such pairs were silently dropped in keyword mode.)
• Optimistic concurrency. Two sessions editing the same memory can't clobber each other; the loser gets the current file back and merges.

Survives compaction, three layers deep

When Claude Code compacts a long session, the conversation gets summarised and details die. githippo makes sure what matters doesn't.

flowchart LR

A[Context fills up] --> B[PreCompact hook] B -->|parse transcript, no LLM| C[checkpoint: goal, todos, files, where it stopped] C --> D[(local ~/.githippo)] C --> E[(repo sessions/)] F[Compaction] --> G[SessionStart hook, source=compact] D --> G G -->|injects the state itself, not a reminder to read it| H[Claude continues exactly where it stopped] I[MCP instructions + core memory] -.->|system prompt, never compacted| H

1. Core memory in the system prompt. MCP server instructions aren't part of the conversation, so compaction can't touch them. Your pinned facts are always there, in any MCP client.
2. Hook-driven checkpoint (Claude Code). A common complaint is that a post-compaction hook which only *reminds* Claude to re-read a state file is hit or miss. githippo injects the content directly. The checkpoint is capped at about 900 tokens; when a session is too big for that it drops the lowest-value detail first (the earlier summary, commands, older requests, finished tasks) and never the goal, the open tasks or where it stopped.
3. `checkpoint` tool (any client, including claude.ai). Claude saves task, state and next step at milestones. After context loss, checkpoint with no args restores it.

Bonus: a fresh session in the same project and branch within 24h gets a brief "last time you were…" note, including what changed in git since (commits, commits by others, branch switches, deleted files). The UserPromptSubmit hook proactively surfaces up to three relevant memories when the match is confident. It's capped at 300 tokens, skips trivial prompts and never repeats within a session. Words in your prompt that the vault has never seen count against a match, so an ordinary coding prompt that shares two generic words with a note ("refactor", "use") is not given memory: on 1,000 to 10,000 notes none of 20 unrelated coding prompts triggered an injection, while all 40 planted questions did, with the right note (test/report6-hook.test.js). Before compaction, githippo also tells the compactor what must survive, and after compaction it keeps the compactor's summary with the checkpoint.

How we know the hooks do what we say: the contracts were read from Claude Code's own code (2.1.258). PreCompact passes each successful hook's stdout to the compactor as custom instructions (Claude Code also shows that text in the transcript as "PreCompact … completed successfully"); PostCompact receives compact_summary; every hook receives session_id, transcript_path and cwd; SessionStart sources are startup, resume, clear, compact and fork.

Recall also learns what you actually use: memory that keeps being handed to Claude gets a small boost (at most +40% on its keyword score, +10% on its semantic score) that halves every 30 days without use. It is applied to those raw scores, so it only reorders results that were nearly tied: it can't push a clear match out of first place (an earlier version applied it after rank fusion and did, see test/report6-ranking.test.js). The counts stay on your machine, are kept per user, and with no usage data ranking is exactly the same as without it.

Wrap anything in … and it never reaches memory. An opening tag that is never closed makes everything after it private, and remember refuses the fact and tells you why, rather than silently keeping the part you meant to hide. Turn hooks off without editing files: GITHIPPO_HOOK_PROFILE=minimal or GITHIPPO_DISABLED_HOOKS=prompt,steer.

Quality, measured (and what isn't)

Retrieval, on a small labelled set (52 queries) and on LongMemEval-S (500 questions, retrieval only, no LLM):

Reproduce the first with githippo eval. Method, per-language breakdown, filing and duplicate accuracy, memory use and scale numbers are in docs/benchmarks.md. The set is small, hand-written by the author and in-domain: a regression guard and a rough guide, not a leaderboard.

Not measured yet, and it is the number that matters most: whether answers get better, or sessions cheaper, with githippo than without it. eval/qa.js and eval/behavior.js are built to measure exactly that and need an ANTHROPIC_API_KEY; they have not been run. Until they are, read "saves tokens" as: it adds a bounded cost to every turn (below) and pays that back only when a recalled fact replaces re-explaining or re-discovering something. If you run them, post the results in issue #3.

Should you use githippo?

• Claude's built-in memory is the zero-setup choice. Use githippo if you want the memory as files you can read, diff, edit