Hippocampus

MCP文档知识

提供方 未标注

文档知识 未标注 API Key 社区 / 第三方 ClaudeCursorVS CodeGemini CLI

由你自行托管的长期记忆,可供每个 Claude Code 会话和设备共享。使用纯 Markdown 文件、混合搜索(BM25 + 本地 ONNX 嵌入 + 手动编写的链接),并为每条记忆设置状态,让已解决的问题不再以未解决状态显示。

一句话选型结论

按资料字段整理

Hippocampus 属于文档知识类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude、Cursor、VS Code 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Hippocampus当前 未标注 未标注 未标注 无 2026-11-20
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-11-20上游最后核验时间

详细介绍

13.1 KB
来自项目仓库与上游目录的原文,未做删改

Hippocampus

Self-hosted, persistent long-term memory for Claude Code and other MCP clients.
One memory server shared by every session, every project and every machine.

English · Português


Hippocampus is an MCP memory server you run yourself. It stores memories
as plain Markdown files, indexes them in SQLite, and finds them with hybrid
search: BM25 keywords + vector embeddings + a knowledge graph
of links that
you (or Claude) write between notes. Claude Code hooks recall relevant
memories on every prompt and curate the memory at the end of each session.

Why Hippocampus?

Claude Code keeps memory per project folder. Open a session in another
folder, or on another machine, and everything learned elsewhere is gone:
which server runs what, how to reach the production database without being
blocked, what was already fixed last week. You end up explaining the same
things over and over, and Claude keeps retrying approaches that already failed.

Hippocampus moves those memories to one memory server you own, on your own
computer or on a small VPS, and wires it into Claude Code, so that every session:

  • recalls automatically. A hook searches memory on every prompt and
    injects the few notes that matter, before Claude starts working.
  • writes to the shared memory. Claude gets MCP tools to search, read, save
    and update memories, and they are visible everywhere at once.
  • tracks what is still open. Each memory has a status
    (active · pending · resolved · superseded), so "what's still pending?" has
    a real answer, and resolved items stop showing up as open.
  • curates itself. At the end of a session an optional hook reviews the
    transcript, closes pending items that got done and saves new durable facts.

Memories are plain Markdown files. The database is only an index you can
delete and rebuild at any time. Embeddings run locally (ONNX): no API key
is needed and your notes never go to a third party.

Example: what Claude receives

Claude calls search_memory("restic backup on nas-1 is failing, disk full?")
and gets this back (real output from the sample memories,
trimmed):```text

Relevant memories for: restic backup on nas-1 is failing, disk full?

backup-restic-nas (reference | project infra | 2026-01-20 | via meaning+name+text)

Nightly restic backups to nas-1: schedule, retention, and how to restore a single file.
...
Disk usage history: [[nas-disk-full-march]].

nas-disk-full-march (project | project infra | 2026-03-20 | RESOLVED on 2026-03-21 | via graph neighbour)

nas-1 hit 98% disk in March: old restic snapshots were never pruned. Fixed by adding prune to the timer.
...

> Old facts may be stale: check the date before acting on them.


The first note was found by keywords **and** meaning. The second came in
through the `[[nas-disk-full-march]]` link written in the first one, and it is
labelled as a resolved incident, so Claude treats it as history, not as the
current state. The recall hook injects the same kind of block on every prompt,
in a lighter form (fewer results, no link expansion) because it is paid on
every message.

Other things you can say in any session, on any machine:

- *"What's still pending on the shop API?"* → `list_pending`
- *"Save to memory how we fixed the orders report."* → `save_memory`
- *"The disk issue is fixed, mark it resolved."* → `mark_memory`

## How it works```mermaid
flowchart LR
    subgraph Laptop["Your machines"]
        CC["Claude Code"]
        H1["recall hook<br/>(every prompt)"]
        H2["sync hook<br/>(end of turn)"]
        H3["extract hook<br/>(end of session)"]
    end
    subgraph Server["Your server"]
        API["Hippocampus<br/>MCP + REST + web"]
        MD[("Markdown files<br/>source of truth")]
        IDX[("SQLite index<br/>FTS5 + vectors + links")]
    end
    CC -- MCP tools --> API
    H1 -- /api/search --> API
    H2 -- /api/import --> API
    H3 -- "claude -p + MCP" --> API
    API --> MD --> IDX

A search mixes three signals:

  1. BM25 (SQLite FTS5) for exact names, ports, flags and numbers;
  2. vectors (paraphrase-multilingual-MiniLM-L12-v2, 384 dims, per section
    rather than per file) for meaning, in 50+ languages;
  3. the link graph: each [[other-memory]] a human or Claude wrote adds a
    one-hop expansion that similarity search cannot infer.

The first two are fused with Reciprocal Rank Fusion. Resolved and superseded
memories are demoted but still findable. The reasoning behind each choice is in
docs/design.md.

How this differs from a vector-database memory

A memory that is only "embed every note, return the nearest vectors" misses
several things that matter for an agent working on real systems:

vectors only Hippocampus
Exact tokens (5432, --force, a hostname) often lost in the embedding BM25 (FTS5) ranks them directly
Long notes one vector per note blurs its topics one vector per ## section
"This depends on that" cannot be inferred from similarity hand-written [[links]] expand results one hop
Outdated facts returned as if still true resolved / superseded demoted and labelled with a date
Open work not modelled pending status and list_pending
Storage opaque database Markdown files; the index can be rebuilt with hippocampus sync --full
Embeddings often a hosted API local ONNX model, no API key

Screenshots

The web UI shows the whole memory as a constellation, which you can search,
open, edit and filter by project.

Quick start

1. Choose where it runs

On your computer On a server (VPS)
Good for one machine, trying it out several machines, phone, claude.ai
You need Python 3.10+ a small VPS (1 GB RAM + 2 GB swap) and a domain
Memory reachable from this computer only everywhere you use Claude
Setup ~5 minutes ~15 minutes

You can start local and move to a server later: memories are plain files, so
you just copy the memories folder.

2a. On your computer```bash

git clone https://github.com/marcelinollima/hippocampus && cd hippocampus
pip install .
hippocampus init # creates ~/.hippocampus with a data folder and a token
hippocampus autostart # starts the server now and at every login (no terminal to keep open)
python clients/claude-code/install.py --url http://127.0.0.1:8765


That's all: open a new Claude Code session. The web UI is at
, and it asks for the token saved in
`~/.hippocampus/server-token`. To load the sample memories, copy
`examples/memories/*` into `~/.hippocampus/data/memories/`.

`autostart` uses the Startup folder on Windows, a LaunchAgent on macOS and a
systemd user unit on Linux. None of them needs admin rights, and
`hippocampus autostart --remove` undoes it. If you prefer Docker, use
`docker compose -f docker-compose.local.yml up -d` (instructions are at the top
of that file).

### 2b. On a server```bash
git clone https://github.com/marcelinollima/hippocampus && cd hippocampus
cp .env.example .env         # set DOMAIN and HIPPOCAMPUS_TOKEN
mkdir -p data                # memories + index live here (back it up)
docker compose up -d         # Hippocampus + Caddy with automatic HTTPS

If you don't use Docker, see deploy/systemd.
Then, on every machine where you use Claude Code:```bash
python clients/claude-code/install.py --url https://memory.example.com --token <TOKEN>


The installer registers the MCP server (user scope) and the three hooks. It
backs up `~/.claude/settings.json` first, and `--uninstall` reverses
everything. Your existing Claude Code memory folders
(`~/.claude/projects/*/memory`) are uploaded on the next sync.

To use the same memory from claude.ai (web, desktop and mobile), see
docs/claude-ai.md.

### 3. Use it

Nothing changes in how you work. Ask Claude something about your
infrastructure and look for the `` block it received. To
teach it something, say *&quot;save this to memory&quot;*.

## MCP memory tools

The server speaks MCP over streamable HTTP, so any MCP client that supports it
can use these tools. The automatic recall, sync and curation hooks are
specific to Claude Code.

| tool | what it does |
|---|---|
| `search_memory(query, limit)` | hybrid search; returns a context block ready to use |
| `read_memory(name)` | the full memory, with its links in and out and similar memories |
| `save_memory(name, description, body, type, project, status)` | create or update; points to pending items that look alike |
| `mark_memory(name, status, note)` | change the status and append a dated note; same hint |
| `list_pending(project, limit, offset)` | what is still open, oldest first, paged |
| `list_memories(project)` | browse by project |

## Memory format

The format is the one Claude Code already uses for its own memory files, so
existing notes work as they are:```markdown
---
name: shop-api-deploy
description: &quot;How to deploy the shop API: build, copy, restart, check.&quot;
metadata:
  type: reference          # project | reference | feedback | user
  status: active           # active | pending | resolved | superseded
---

## Steps
1. `python -m compileall src` first: one SyntaxError takes down every route.
...
Related: [[shop-api-db-access]]

Folder = project: data/memories//.md. You can edit files on
disk and run hippocampus sync, or use the web UI, or let Claude do it.

Configuration

All server settings are environment variables. .env.example
documents each of them. The most useful ones:

variable purpose
HIPPOCAMPUS_TOKEN bearer token for MCP, API and web UI (required)
HIPPOCAMPUS_OWNER your name, used in the instructions Claude receives
HIPPOCAMPUS_LANG en (default) or pt: language of the MCP instructions and of what the server writes into Claude's context
HIPPOCAMPUS_PINNED a memory injected on top of every recall, e.g. a map of "nickname → repo, server, database"
HIPPOCAMPUS_URL_SECRET enables /mcp/ for clients that can't send headers, such as claude.ai custom connectors (guide)
HIPPOCAMPUS_MODEL any fastembed text model

The client side lives in ~/.hippocampus/client.json, which is written by
the installer. There you can map local project folders to server projects,
add extra memory folders, or turn off automatic extraction. Install with
--lang pt to get the recall header and the automatically extracted
memories in Portuguese. The web UI follows your browser's language and has
an EN/PT button to switch.

Security

Memories tend to contain exactly what an attacker wants: hostnames, database
names and access recipes. Hippocampus is built around that:

  • one bearer token, compared in constant time, on every route except / and /health;
  • the app listens on 127.0.0.1 only, behind a TLS proxy (Caddy);
  • DNS-rebinding protection on /mcp (explicit list of allowed hosts);
  • recalled memories are labelled as notes, not instructions, and the
    extraction prompt treats the transcript as evidence only.

Read SECURITY.md before exposing a server, and never commit
your data/ folder.

CLI```

hippocampus init # prepare a local install (~/.hippocampus + token)
hippocampus autostart [--remove] # run the server at every login (Windows, macOS, Linux)
hippocampus serve # MCP + API + web (syncs on start)
hippocampus sync [--full] # index new/changed files, or rebuild everything
hippocampus suggest-links # compute "similar" edges for the constellation
hippocampus stats # counts, broken links, pending items
hippocampus token # generate a random token


Pending items pile up when the fix is written somewhere else. To review them,
run the Claude Code client&#x27;s reviewer (it uses `claude -p`, with no tools):```
python ~/.hippocampus/hooks/review.py            # report: which pending items look done
python ~/.hippocampus/hooks/review.py --apply ~/.hippocampus/review-&lt;date&gt;.json

It only marks what the report lists as resolved with a quote as proof, and
you can veto any item by setting &quot;apply&quot;: false in the .json first.

On a server, the review can run by itself once a day
(deploy/systemd/hippocampus-review.service),
with Claude Code under your subscription. It only looks at items that changed
or got newer evidence since their last review, and HIPPOCAMPUS_REVIEW says
what to do with the result: off (default), report (list_pending shows
"looks done" with the quote, for a person to confirm) or apply (marks them
resolved; undo by marking them pending again).

Project status

Hippocampus came out of its author's daily work, where it holds 360+
memories across 9 projects. It is young (0.x): expect rough edges and please
report them. CI runs the tests on Linux and Windows, a Docker smoke test, a
secret scan, and the full local install on Windows and macOS.

Known limitations:

  • one token per server: it is a personal memory, not a multi-user one;
  • automatic recall and curation hooks exist for Claude Code only; other MCP
    clients get the tools but must call them themselves;
  • link expansion is one hop, over hand-written links only (by design, see
    docs/design.md).

Bug reports and ideas are welcome in the
issues, and
contributions in English or Portuguese. See CONTRIBUTING.md.
Changes are listed in the CHANGELOG.

License

MIT

常见问题

6 问
答案由本站依据条目字段整理,不引用上游原文
Hippocampus 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Hippocampus 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Hippocampus 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Hippocampus 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Hippocampus 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Gemini CLI、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Hippocampus 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-11-20。