Potencia tu agente
Instalación del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
Aún no hay una versión empaquetada en el registro. Sigue el README del repositorio.
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDel publicador
Coding agents already have memory. CLAUDE.md, AGENTS.md, your notes folder, that growing pile of project READMEs. Stuff persists just fine.
The problem is how the agent consumes it. Every session starts by re-reading the whole pile from scratch — every Read, every Grep, scanning raw prose the agent has already processed dozens of times. Big context windows don't fix it. A 1M-token window is still paid per call, and still can't tell yesterday's stale note from today's relevant one.
An agentic memory database that cuts session tokens by 82–99%. One portable SQLite file — your agent's memory, anywhere.
Raw markdown is the wrong shape for memory. Not because it can't hold the words — it can — but because it forces the agent to pay full freight on every read.
remindb is a single SQLite file your agent treats as long-term memory. It parses your notes (Markdown, HTML, JSON, YAML, TOON) into a structured tree, hashes every node, encodes repetitive structures compactly when it saves tokens, and surfaces the whole thing through a tight MCP tool suite.
Each point is a summary — the full reasoning, with the tradeoffs, lives in docs/.
An ICR the agent can index, not skim. MemoryTree returns the Intermediate Context Representation — typed, labeled, token-counted — in one call instead of a directory walk and a pile of file reads. → The node tree
Hot vs. cold, like a real cache. Every node has a temperature that rises when it's read and decays over time. Hot nodes rank higher in search; cold ones stop crowding the top without ever being deleted. → Temperature
Summarization that happens when it should. When a node crosses the cold threshold the server nudges the agent to compact it in place — same anchor, same history, fewer tokens. No cron, no worker; it's driven by how the memory actually gets used. → Temperature
Git-style versioning, free. Every compile or write lands a snapshot with per-node diffs. A returning agent resyncs with MemoryDelta — a tiny payload instead of a whole-file re-read. → Versioning
TOON encoding where it pays off. Arrays of uniform objects store ~40% smaller in TOON than YAML or JSON. The parser tries both per node and keeps the win only when it's real; irregular prose stays plain text. The same ≥15% rule converts MathML in HTML to compact LaTeX. → TOON encoding · MathML → LaTeX
FTS5 search, not grep. Ranked anchors in milliseconds over a porter-tokenized index — no file rescans, no regex timeouts — trimmed to exactly the token budget you pass. → Search
Knowledge graph from lateral relations. Author [[Architecture; w=2.5]] in any payload and the compiler resolves a directed weighted edge; MemoryRelated traverses it up to 5 hops, ranked by path weight. Forward references self-heal. → Knowledge graph
Portable by design. The whole memory is one .db file. Copy it to another machine, hand it to another agent, commit it into a repo, sync it across devices. No server, no daemon, no external state — any MCP-capable agent can point serve at the same file and share the same knowledge.
Linux / macOS:
curl -fsSL https://raw.githubusercontent.com/radimsem/remindb/main/install.sh | bash
By default the binary lands at ~/.local/bin/remindb. Pick a different prefix:
curl -fsSL https://raw.githubusercontent.com/radimsem/remindb/main/install.sh | bash -s -- --prefix /usr/local
Windows (PowerShell 5.1+):
iwr -useb https://raw.githubusercontent.com/radimsem/remindb/main/install.ps1 | iex
Lands at %LOCALAPPDATA%\Programs\remindb\bin\remindb.exe. Override with -Prefix:
./install.ps1 -Prefix C:\tools\remindb
git clone https://github.com/radimsem/remindb.git
cd remindb
go build -o ~/.local/bin/remindb ./cmd/remindb
Verify:
remindb --version
Two moving parts: the binary (release tags) and the agent-side skills (remind, memorize — the markdown your agent loads to learn how to call the MCP tools). They iterate on different cadences, so they update independently.
remindb update
Reads the installed version, compares it against the latest GitHub release, and re-runs the install script only when they differ. dev-builds (from go build / go install) always proceed — there's no published version to compare against. Pass --force to reinstall regardless:
remindb update --force
The public skills live under skills/: remember (the plain-language front door), remind (read path), memorize (write path), and remindb-setup (connectivity/config). remind and memorize use progressive disclosure — a compact SKILL.md plus on-demand references/. They're refreshed by vercel-labs/skills.
First-time install — globally (every detected agent), or scoped to one agent:
# Global — install for all detected agents at once
npx skills@latest add radimsem/remindb/skills
# Scoped — install for one agent
npx skills@latest add radimsem/remindb/skills -a claude-code
# -a codex | gemini-cli | opencode | openclaw | hermes-agent | ...
Refresh later:
npx skills@latest update
The README is the trailer. The manual is in docs/ — each page opens with the problem it solves, in plain language.
A Memory* tool suite, registered once, surfaced to any MCP-capable agent (Claude Code, Codex, Gemini CLI, OpenCode, OpenClaw, Hermes Agent, …). The read path is documented in the remind skill, the write path in memorize.
Resources give desktop clients and dashboards passive read access to database state. Unlike the Memory* tools, they never boost temperature, take locks, or emit snapshots — a heatmap that warmed the nodes it displayed would measure its own rendering.
Several are subscribable — clients can receive push notifications on state changes instead of polling. The full resource contract, envelope shapes, and subscription events are in docs/resources.md.
Six plugin folders ship with the repo, one per supported agent host. Five are short declarative manifests matching the host's plugin spec; the Hermes Agent one is a Python MemoryProvider implementation that spawns remindb serve as a subprocess. Each folder has a README with install commands, env-var conventions, and a worked example.
[!TIP] Pair the plugin with the two companion skills —
remind(read path) andmemorize(write path). They teach the agent the MCP tool suite so you don't re-explain it each session. Per-agent install instructions live inskills/README.md.
For any other MCP-capable agent, add this to its MCP config by hand. Stdio (the default — one server per client process):
{
"mcpServers": {
"remindb": {
"type": "stdio",
"command": "remindb",
"args": ["serve"],
"env": {
"REMINDB_DB": "/absolute/path/to/memory.db",
"REMINDB_SOURCE": "/absolute/path/to/notes"
}
}
}
}
Every serve flag has a REMINDB_* environment equivalent — REMINDB_DB, REMINDB_SOURCE, REMINDB_RESCAN_INTERVAL, REMINDB_TRANSPORT, REMINDB_LISTEN, REMINDB_INSECURE_PUBLIC — plus the env-only REMINDB_AUTH_TOKEN for HTTP bearer-token auth (see SECURITY.md). Pass them via args, the env block above, or a committed .remindb/config.json. Precedence is explicit flag → .remindb/config.json → env → built-in default; see Configuration.
Or HTTP, when you want one long-running server that multiple agent sessions (a local IDE, a CI worker, a hosted session) share. Start remindb serve --transport http --db ... --source ... once, then point each client at the listen URL:
{
"mcpServers": {
"remindb": {
"type": "http",
"url": "http://127.0.0.1:7474"
}
}
}
On startup the agent sees the full Memory* tool suite alongside its usual toolbox.
You don't hand-write any of that, though — the remindb-setup skill (installed via npx skills add, above) is a config-first wizard that runs from inside a session. Because the skill installs independently of the MCP plugin, its first pass runs before any server is attached. On hosts that expose it as a slash command (Claude Code, OpenClaw):
/remindb-setup # interactive — walks you through each .remindb/ choice
/remindb-setup automode # hands-off — the agent infers the whole setup itself
Codex, OpenCode, and Gemini CLI surface the same skill differently — the /skills picker, a $remindb-setup mention, or plain-language activation; each plugin README gives the exact invocation. Either way, it detects the host, authors .remindb/ (ignore/pinned/temperatures.json/config.json) before compiling — so those settings apply at insert time, no reseed retrofit — runs the compile, offers to seed adjacent context (CLAUDE.md/AGENTS.md/README), and wires the MCP env for you using your host's durable mechanism. Then you enable the plugin and restart; re-running the wizard with the server attached is the verify pass (MemoryStats + remindb://doctor). Per-host invocation and env details live in skills/remindb-setup/. (Hermes Agent is a memory-provider bridge, not an MCP-config host — it uses hermes memory setup instead; see its plugin README.)
Once that's done, talking to your memory is plain language — the /remember front door routes recall to remind and saves to memorize, so you never name a tool:
/remember what did we decide about <topic>? Pull it from memory — don't re-read the files.
It searches the node tree, fetches the top hits under a token budget, and answers from memory, citing which file each fact came from — instead of grepping and re-reading prose it has already seen. The same door takes saves: /remember note that <fact> routes to a structured write.
Token counts are measured against the naive baseline an agent falls back to without a memory layer: list the directory, read every matching file, grep through it. Numbers come from ./scripts/bench-agents.sh over the five plugin fixtures in testdata/, plus a one-off compile of a real Obsidian vault (~450 markdown files across AI concepts, market briefs, security notes, and MOCs — ~3.3M naive tokens end-to-end).
The scenario suite (tree · 3 searches · fetch · delta) rolls up into three workflow categories:
MemoryTree orientation call.MemorySearch + MemoryFetch + MemoryDelta, token-weighted.[!NOTE] Corpus size moves the numbers in remindb's favour. The plugin fixtures are ~3k–20k tokens each; the vault is ~3.3M. As the corpus grows, the naive baseline scales linearly (more files to list, more bytes to grep, more prose to re-read), while remindb's answers stay bounded by the token budget you pass. That's why the vault's context-gathering row hits 99.8% — every search still returns ~1k tokens, but the baseline is now ~100× larger.
The scenario list is also intentionally short. A real 30-minute agent session does dozens of orient/search/fetch/write/re-orient cycles, and the same search often fires three or four times as the agent loops on a problem. Each of those calls compounds toward 90%+ full-session savings on realistic corpora. The
obsidian vaultrow is a real vault: ~450 markdown files, ~3.3M naive tokens.
Reproduce the table yourself:
./scripts/bench-agents.sh
This is a project I maintain between classes — patches, bug reports, and ideas are genuinely welcome, and an extra pair of eyes goes a long way. The full guide lives in CONTRIBUTING.md: branch naming, the pre-PR checklist, the doc-update map, and how the AI-assisted workflow is wired up. If you want to start small, the "First-time contributors" section there has good entry points.
MIT — see LICENSE.
I'm a college student building agentic AI tooling in the evenings and weekends between classes. remindb is free, MIT-licensed, and will stay that way — no telemetry.
If this saved you tokens (or saved you from reading the same 100 files for the hundredth time), even a small tip helps a lot.
Or send BTC to bc1qwyxsx7sledl4pru8y5ykd54fevsklytrv95ual.
Thanks for reading this far. If you end up using remindb in anger, I'd love to hear what you built — open an issue with a short story, or drop a star. Both matter more than you'd think.
An agentic memory database that cuts session tokens by 82–99%. One portable SQLite file — your agent's memory, anywhere.
Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Remindb se ejecuta localmente por stdio.
Última comprobación: 2026-10-26. An agentic memory database that cuts session tokens by 82–99%. One portable SQLite file — your agent's memory, anywhere.
