Gives AI agents a persistent hierarchical memory so they recall projects, decisions, errors and sessions across devices and providers.
Also known as Bumblebiber/hmem, hmem, hmem-mcp
- Stars
- 24
- Tools
- 25
- Downloads, 30 days
- —
- Latest version
- 1.6.7
- Last commit
- Nov 1, 2026
- License
- MIT
What is hmem MCP?
hmem gives AI agents a persistent hierarchical memory so they recall projects, decisions, errors and sessions across devices and providers. It exposes 25 tools, such as hmem, hmem-curate, read_memory.
Summary generated from the project's README
About hmem MCP server
Providing AI agents with a persistent, hierarchical memory framework is what hmem enables for developers working across different devices and providers. It solves the problem of agents losing context between sessions by allowing them to recall specific projects, past decisions, and previous errors through a structured 5-level lazy loading system. This ensures that agents only consume the tokens necessary for the current task, rather than re-reading entire codebases every time a new conversation starts.
Users can deploy this via two distinct MCP servers: a daily-use server containing 13 tools like load_project and write_memory, and a maintenance server called hmem-curate for bulk edits and schema migrations. The system works locally and supports portability across Claude, Gemini, GPT, and local models. It features automatic session capture and background checkpoints using a Haiku subagent to extract lessons learned without interrupting the main workflow. Developers can also integrate the memory directly into their own automation pipelines using the provided TypeScript SDK.
What you can do with it
- 1Restore project context instantlyAn AI agent can immediately understand a project's stack, architecture, and recent bugs using a single command.
- 2Automate long-term knowledge extractionA background subagent can automatically summarize conversations into permanent memory to prevent repetitive questions.
- 3Maintain shared team knowledgeMultiple team members can use a centralized memory store to keep all agents aligned on company standards.
- 4Perform bulk memory maintenanceDevelopers can clean up large amounts of stored data or rename tags across all entries using specialized tools.
Written from the project's README. Every use case is checked against a quote from it.
How to install hmem MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall hmem MCP in Claude Code
$ claude mcp add hmem -- npx -y hmem-mcpInstall hmem MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"hmem": {
"command": "npx",
"args": [
"-y",
"hmem-mcp"
]
}
}
}Install hmem MCP in VS Code
.vscode/mcp.json
{
"servers": {
"hmem": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"hmem-mcp"
]
}
}
}Install hmem MCP in VS Code CLI
$ code --add-mcp '{"name":"hmem","type":"stdio","command":"npx","args":["-y","hmem-mcp"]}'Install hmem MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"hmem": {
"command": "npx",
"args": [
"-y",
"hmem-mcp"
]
}
}
}Install hmem MCP in Codex
$ codex mcp add hmem -- npx -y hmem-mcpInstall hmem MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.hmem] command = "npx" args = ["-y", "hmem-mcp"]
Install hmem MCP in Gemini CLI
$ gemini mcp add -s user hmem npx -- -y hmem-mcpInstall hmem MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"hmem": {
"command": "npx",
"args": [
"-y",
"hmem-mcp"
]
}
}
}hmem MCP tools 25
Detected from the READMEhmemhmem-curateread_memorywrite_memoryappend_memoryupdate_memorysearch_memoryfind_relatedload_projectread_projectcreate_projectlist_projects
Show all 25 toolsShow fewer tools
flush_contextmove_nodesset_active_devicememory_statsmemory_healthexport_memoryimport_memoryupdate_manytag_bulktag_renamemove_memoryrename_idreset_memory_cache
Configuration
HMEM_AGENT_IDHMEM_PATHHMEM_PROJECT_DIRHMEM_STORAGE_DIRDirectory where .hmem SQLite databases are stored. Defaults to ~/.hmem/
Automated checks
Ran Nov 12, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledPass
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubhmem — Humanlike Memory for AI Agents
Your AI forgets everything between sessions. hmem fixes that.
One load_project() call. ~3000 tokens. Your agent knows everything important about a project — every past mistake, every decision, every open task — across sessions, devices, and AI providers. No setup per conversation. No "let me re-read the codebase." It just remembers.
AI agent? Skip this file. Read AGENT_SETUP.md — written for you, not for humans.
Naming note (v8.0): This package was briefly published as
its-over-9k(1.x). It is nowhmemagain — pure memory framework, nothing else. Theits-over-9kname lives on as a separate project: the o9k token-efficiency meta-framework, which combines skills/plugins like this one. Related: TIM — hmem's next-generation successor (hypergraph memory, CRDT sync).
What This Is
hmem is not a note-taking plugin. It's a memory framework for AI agents — a complete infrastructure layer for persistent, portable, token-efficient knowledge that survives session boundaries, device switches, and provider changes.
Four core guarantees:
| Pillar | What it means |
|---|---|
| Token efficiency | 5-level lazy loading — you pay for what you read, never more |
| Portability | Same memory across Claude, Gemini, GPT, local models, any MCP client |
| Efficient storage | Hierarchical tree structure — context scales with depth, not flat append |
| No context waste | Auto-session capture + project briefing = zero re-read overhead |
The Problem
Every AI session starts from zero. Your agent asks the same questions, makes the same mistakes, contradicts last week's decisions, and wastes 50k tokens loading context it already processed yesterday.
You've tried workarounds — CLAUDE.md files, custom prompts, manually pasting context. They don't scale. You have 10 projects. You switch between 3 devices. You use different AI tools.
The Solution
You: "Load project"
Agent: [calls load_project("P0048") — 3000 tokens]
Agent: "v1.2.9, TypeScript/SQLite/npm. 3 open bugs, 8 roadmap items.
Last session: rebrand complete, rename_id bug fixed (89 changes).
Next: O-Entry Auto-Purge. What's the focus today?"
That's it. 3000 tokens for a complete project briefing. The agent knows the stack, the architecture, the open bugs, the recent decisions, and exactly where you left off — even if "you" was a different AI on a different machine yesterday.
How It Works
Level 1 ── One-line summary (always loaded — ~5k tokens for 300+ entries)
Level 2 ── Paragraph detail (loaded on demand)
Level 3 ── Full context (loaded on demand)
Level 4 ── Extended detail (loaded on demand)
Level 5 ── Raw/verbatim data (loaded on demand)
At session start, the agent loads Level 1 summaries — one line per memory. When it needs detail, it drills down. Your 300-entry memory costs 5k tokens to overview. A single project costs ~3000 tokens.
Nothing is summarized away. Level 1 is a compressed view, but Levels 2–5 hold the complete original text, word for word, accessible on demand.
Framework Features
Automatic Session Memory
Every conversation is recorded automatically. No "save your work" prompts. No manual checkpoints.
You type → Agent responds → Stop hook fires → Exchange saved to O-entry
→ Linked to active project
→ Haiku auto-titles the session
Switch projects mid-session? The O-entry switches too. Start a new session on a different device? The next agent sees every exchange from every device — the conversation never dies.
Haiku Background Checkpoints
Every N exchanges (configurable, default 5), a Haiku subagent wakes up in the background. It reads the recent conversation, extracts lessons learned, errors encountered, and decisions made, then writes them to long-term memory — with full MCP tool access. Your main agent is never interrupted.
The checkpoint also writes a handoff note to the project: "Here's what was done, here's what's in progress, here's the next step." The next agent — on any device, any provider — picks up exactly where you left off.
Project-Based, Not Session-Based
Sessions are meaningless. Projects are everything.
- O-entries are linked to the active project, not the session
- Checkpoint counters count project exchanges, not session messages
load_projectshows recent conversations with full context — across all devices
Skills System
hmem ships with a complete skills layer — structured behavior files that agents load on demand. Skills define how an agent should do something (debug, write memory, curate entries, handle a session start) — separate from memory, separate from prompts.
npx hmem update-skills # Pull latest skills to your AI tool's skill directory
Skills are versioned and updated independently. Your agents get smarter without reinstalling. 21 skills ship by default:
| Skill | Triggers when… |
|---|---|
hmem-session-start |
Every session start — loads project + surfaces pending git work, open tasks, misrouted O-entries |
hmem-using-hmem |
Meta-skill loaded at session start; defines mandatory memory habits |
hmem-read |
Reading from long-term memory (search, prefix filter, find_related, cross-project read) |
hmem-write |
Writing to hmem — picks prefix, tree location, tags, detects duplicates |
hmem-search |
User references something without an ID ("the bug we had", "letzte Woche") |
hmem-new-project |
Creating a P-entry — handles schema, sections, O-entry linking |
hmem-new-error |
Creating an E-entry with the strict 5-level scaffold |
hmem-activate |
Switching active project mid-session, plus fixing misrouted exchanges |
hmem-context |
Loading specific context when load_project output isn't enough |
hmem-recall |
Dispatching a Haiku sub-agent to search hmem |
hmem-dispatch |
Dispatching an isolated sub-agent for any search/lookup/calculation |
hmem-curate |
Cleaning up an .hmem file (mark obsolete, fix titles, consolidate dupes) |
hmem-migrate-o |
Migrating O-entries to the project-bound 5-level structure |
hmem-consolidate |
Merging session checkpoint summaries into one final O-entry summary |
hmem-wipe |
Prep for /clear — save high-value knowledge, update Next Steps |
hmem-config |
View/change memory settings, hooks, sync, checkpoints |
hmem-setup |
First-time install of hmem for Claude Code / Gemini CLI / OpenCode |
hmem-sync-setup |
Set up hmem-sync for cross-device sync |
hmem-update |
Update flow — runs npm update -g, syncs skills, applies migrations |
hmem-release |
Pre-publish checklist for hmem itself |
hmem-subagent |
Template for sub-agents dispatched by hmem-dispatch |
Company Memory
Beyond personal memory, agents can maintain a shared company store — a separate company.hmem that multiple agents and team members can read from. Personal and company memory coexist; agents query both simultaneously.
import { openCompanyMemory } from 'hmem';
const store = openCompanyMemory('/path/to/project');
Embeddable SDK
hmem ships as a fully documented TypeScript SDK — import HmemStore directly into your own agents, tools, or automation pipelines:
import {
HmemStore, openCompanyMemory, resolveHmemPath,
loadHmemConfig, saveHmemConfig, DEFAULT_CONFIG, DEFAULT_PREFIXES, formatPrefixList,
searchMemory,
} from 'hmem';
import type {
AgentRole, MemoryEntry, MemoryNode, HmemConfig,
SearchResult, SearchOptions, SearchScope,
} from 'hmem';
const store = new HmemStore('/path/to/agent.hmem');
const results = searchMemory('/path/to/project', 'auth token bug', { maxResults: 5 });
MCP Tools
hmem ships two MCP servers:
hmem(daily-use, 13 tools) — read, write, search, project lifecycle.hmem-curate(maintenance, 11 tools) — bulk edits, schema migrations, backup/restore. Activate only when curating.
hmem — daily-use server (13)
| Tool | What it does |
|---|---|
read_memory |
5-level lazy read — by ID, prefix, search, time, or tag |
write_memory |
Create new entries with title, body, tags, links |
append_memory |
Add child nodes to existing entries |
update_memory |
Patch fields: title, body, tags, irrelevant, links |
search_memory |
FTS5 full-text search with sub-node attribution |
find_related |
Find contextually related entries by tag overlap |
load_project |
Activate a project + get full briefing + recent sessions |
read_project |
Read project without activating (comparison/reference) |
create_project |
Scaffold a new project entry with standard schema |
list_projects |
List all projects with status summary |
flush_context |
Persist current session context to long-term memory |
move_nodes |
Move a subtree under a different parent (also in curate server) |
set_active_device |
Register and switch between devices |
hmem-curate — maintenance server (11)
| Tool | What it does |
|---|---|
memory_stats |
Per-prefix counts, total tokens, favorites, hashtags, stale-list |
memory_health |
Find broken links, orphan tags, empty entries, dangling chains |
export_memory |
Export the full .hmem to a portable JSON snapshot |
import_memory |
Import a JSON snapshot back into a .hmem (destructive) |
update_many |
Bulk-patch a set of entries (irrelevant, tags, body, etc.) |
tag_bulk |
Add/remove a tag across many entries |
tag_rename |
Rename a tag globally across all entries |
move_memory |
Move an entire entry to a new ID slot |
move_nodes |
Move a subtree under a different parent (also in main server) |
rename_id |
Rename an entry's ID; rewrites all inbound links |
reset_memory_cache |
Invalidate the in-memory L1 cache (after raw SQL writes) |
The daily hmem server is registered automatically by hmem init. hmem-curate is opt-in because its tools are destructive — register it when you need to curate:
npx hmem mcp-add-curate # adds the curate server to Claude Code (user scope)
Then toggle it via /mcp only during curation sessions. For other MCP clients, see Manual setup.
CLI Commands
After npm install -g hmem-mcp, the hmem binary is on PATH.
User-facing
| Command | Purpose |
|---|---|
hmem init |
Interactive installer for AI tools (Claude Code, OpenCode, Gemini CLI, Cursor, Windsurf, Cline). Flags: --global / --local / --tools <list> / --dir <path> / --no-example |
hmem update-skills |
Copy/sync bundled skill files to detected AI tools (called automatically on npm install) |
hmem mcp-add-curate |
Register the hmem-curate MCP server with Claude Code (opt-in; toggle via /mcp when curating) |
hmem doctor |
Detect stale or deprecated hmem MCP entries in host configs |
hmem stats |
Memory statistics + per-project token estimates + 🔴 4k threshold flagging |
hmem setup-hook |
Re-add the SessionStart hook to Claude Code settings (if removed) |
hmem version |
Show version |
Hook drivers (called by AI tools, not by hand)
| Command | Wired into | What it does |
|---|---|---|
hmem hook-startup |
UserPromptSubmit | First-message context injection (memory overview, project list, sync status). Periodic checkpoint reminders. Reads JSON from stdin |
hmem log-exchange |
Stop (sync) | Append the latest exchange to the active O-entry |
hmem checkpoint |
Stop (async) | Background Haiku/DeepSeek call — extracts lessons, errors, decisions; updates project handoff note |
hmem context-inject |
SessionStart[clear] | Inject project + rules context after /clear |
hmem deactivate |
SessionStart[clear] | Clear active project for current session |
hmem statusline |
statusLine | Render Claude Code statusline (device · active project · checkpoint counter). Reads JSON from stdin |
Curation
| Command | Purpose |
|---|---|
hmem delete <ID> |
Permanently delete an entry (curator only, never synced) |
hmem migrate-o-entries |
Migrate O-entries to the current project-bound schema |
hmem summarize-session <id> |
Generate a summary node for a session |
Sync (requires hmem-sync installed)
| Command | Purpose |
|---|---|
hmem sync push |
Push local memory to the sync server |
hmem sync pull |
Pull latest memory from the sync server |
hmem sync status |
Show server URL · auth state · last-sync timestamp |
hmem sync setup [--join] |
Interactive passphrase + device setup |
Backup / migration
| Command | Purpose |
|---|---|
hmem export-staging <hmem> <json> |
Export .hmem SQLite to a portable JSON staging file |
hmem import-staging <json> <hmem> |
Import a JSON staging file back into a .hmem |
hmem serve starts the MCP stdio server directly — your AI tool launches it automatically; you only run it by hand for debugging.
Memory Categories
Default prefixes (configurable via prefixes in hmem.config.json):
| Prefix | Category | Example |
|---|---|---|
| P | Project | hmem | Active | TS/SQLite/npm |
| L | Lesson | HMEM_AGENT_ID must be set in hooks — resolveHmemPath falls back to wrong DB |
| T | Task | T0033 hmem-sync SaaS monetization — recurring monthly tier design |
| E | Error | 158 spurious O-entries created when Haiku MCP lacked HMEM_NO_SESSION guard |
| D | Decision | Project-based O-entries over session-based — sessions are meaningless |
| M | Milestone | v1.0.0 — package renamed to hmem, npm rebrand complete |
| S | Skill | Skill: TypeScript debugging with source maps |
| N | Navigator | High-level navigation entry (table of contents for a topic) |
| H | Human | User Skill: TypeScript 9, Architecture 9, React 3 |
| R | Rule | Max one npm publish per day — batch changes |
| O | Original | Auto-recorded conversation history (every exchange, every device) |
| I | Infrastructure | Strato Server | Active | Linux | Ubuntu 22.04 |
| C | Convention | Tag scheme: lowercase, prefer existing tags before inventing |
Add custom prefixes (e.g. A for App, F for Function reference) by listing them under prefixes in hmem.config.json — they show up in read_memory({ prefix: "X" }) filters automatically.
Quick Start
1. Install
npm install -g hmem-mcp
2. Run the interactive installer
npx hmem init
Detects your AI tools, creates the memory directory, configures MCP, and installs all hooks:
| Hook | When | What |
|---|---|---|
UserPromptSubmit |
Every message | First message: load memory overview. Every Nth: checkpoint reminder |
Stop (sync) |
Every response | Log exchange to active O-entry |
Stop (async) |
Every response | Haiku auto-titles untitled sessions |
SessionStart[clear] |
After /clear | Re-inject project context |
3. Verify
Restart your AI tool, then:
read_memory()
Empty response = working (first run). Error = check the troubleshooting section.
Manual setup
{
"mcpServers": {
"hmem": {
"command": "/absolute/path/to/node",
"args": ["/absolute/path/to/hmem/dist/mcp-server.js"],
"env": {
"HMEM_PROJECT_DIR": "/home/yourname/.hmem",
"HMEM_AGENT_ID": "DEVELOPER"
}
}
}
}
Find the paths:
echo "Node: $(which node)"
echo "Server: $(npm root -g)/hmem/dist/mcp-server.js"
{
"mcp": {
"hmem": {
"type": "local",
"command": ["/absolute/path/to/node", "/absolute/path/to/hmem/dist/mcp-server.js"],
"environment": { "HMEM_PROJECT_DIR": "/home/yourname/.hmem" },
"enabled": true
}
}
}
Edit ~/.cursor/mcp.json, ~/.codeium/windsurf/mcp_config.json, or .vscode/mcp.json:
{
"mcpServers": {
"hmem": {
"command": "/absolute/path/to/node",
"args": ["/absolute/path/to/hmem/dist/mcp-server.js"],
"env": { "HMEM_PROJECT_DIR": "/home/yourname/.hmem" }
}
}
}
Configuration
hmem.config.json in your HMEM_PROJECT_DIR (or Agents/NAME/):
{
"memory": {
"maxCharsPerLevel": [200, 2500, 10000, 25000, 50000],
"maxDepth": 5,
"checkpointMode": "auto",
"checkpointInterval": 5,
"recentOEntries": 10,
"maxTitleChars": 50,
"prefixes": { "X": "Custom" }
},
"sync": {
"serverUrl": "https://your-server/hmem-sync",
"userId": "yourname",
"salt": "...",
"token": "..."
}
}
| Key | Default | What it does |
|---|---|---|
checkpointMode |
"remind" |
"auto" = background agent writes L/D/E. "remind" = prompts the main agent |
checkpointInterval |
5 |
Exchanges between checkpoints. 0 = disabled |
checkpointProvider |
"anthropic" |
"anthropic" or "openai" (any OpenAI-compatible: DeepSeek, Groq, …) |
checkpointModel |
"claude-haiku-4-5-20251001" |
Model name for the configured provider |
checkpointBaseUrl |
— | OpenAI-compatible base URL (e.g. https://api.deepseek.com/v1) |
checkpointApiKeyEnv |
provider default | Env var holding the API key. Defaults: ANTHROPIC_API_KEY or OPENAI_API_KEY |
recentOEntries |
10 |
How many recent sessions to show in load_project |
prefixes |
built-in | Add custom entry types |
All keys are optional. Missing keys use defaults.
Checkpoint setup per harness
The auto-checkpoint agent runs in the background after every Nth exchange. It needs an LLM call — three paths, picked automatically:
- API key in environment (any harness) → direct provider API loop. Configure
checkpointProvider+checkpointModel+checkpointApiKeyEnvinhmem.config.json. Works from Pi, Hermes, OpenCode, and Claude Code. - No API key, but
claudeCLI in PATH → subprocess fallback (claude -p). Zero-config for Claude Code / Claude Max users. - Neither → checkpoint fails with a config-hint error.
Recommended cheap setup (DeepSeek, ~10× cheaper than Haiku):
{
"memory": {
"checkpointMode": "auto",
"checkpointProvider": "openai",
"checkpointModel": "deepseek-chat",
"checkpointBaseUrl": "https://api.deepseek.com/v1",
"checkpointApiKeyEnv": "DEEPSEEK_API_KEY"
}
}
Then export DEEPSEEK_API_KEY=sk-... in your shell profile. Works for any harness.
Claude Code / Claude Max (zero-config): no provider settings needed — the subprocess fallback uses your existing claude login.
Per-harness exchange logging: Claude Code uses Stop hooks (installed by npx hmem init). Pi uses the built-in extension (src/extensions/pi-hmem.ts). Hermes needs the hermes-hmem plugin (see plugins/hermes-hmem/README.md). OpenCode uses the same hook system as Claude Code.
⚠ Pi users: Hook-based exchange logging is currently not working in the Pi runtime. Exchanges are not saved to O-entries automatically. Manual checkpointing via
hmem checkpointis the workaround until this is resolved.
Cross-Device Sync
Sync memories across all devices with zero-knowledge AES-256-GCM encryption.
npm install -g hmem-sync
npx hmem-sync connect # Interactive wizard — first device creates, others join
Add HMEM_SYNC_PASSPHRASE to your MCP config for automatic sync on every read/write.
Multi-server redundancy
{
"sync": [
{ "name": "primary", "serverUrl": "https://server1/hmem-sync", "userId": "me", "salt": "...", "token": "..." },
{ "name": "backup", "serverUrl": "https://server2/hmem-sync", "userId": "me", "salt": "...", "token": "..." }
]
}
Announcements
Broadcast to all synced agents across all devices:
npx hmem-sync announce --message "Server URL changing — update your config!"
Windows
On Windows with Git for Windows, Claude Code routes hook and statusLine commands through Git Bash by default. Git Bash's MSYS2 runtime crashes transiently at startup, killing the command before it runs.
Fix: add "shell": "powershell" to every hook command and to statusLine in ~/.claude/settings.json.
See settings.windows.example.json for the full working config. Key differences:
{
"env": {
"HMEM_PATH": "C:/Users/YOUR_USERNAME/.hmem/Agents/DEVELOPER/DEVELOPER.hmem"
},
"hooks": {
"Stop": [{
"matcher": "",
"hooks": [{
"type": "command",
"command": "node C:/Users/YOUR_USERNAME/AppData/Roaming/npm/node_modules/hmem/dist/cli.js log-exchange",
"shell": "powershell"
}]
}]
},
"statusLine": {
"type": "command",
"command": "node C:/Users/YOUR_USERNAME/AppData/Roaming/npm/node_modules/hmem/dist/cli.js statusline",
"shell": "powershell"
}
}
Run npm root -g to get the correct node_modules path for your machine.
statusLine on Windows: Stable with
"shell": "powershell". Without it the statusline disappears intermittently.
Troubleshooting
| Problem | Fix |
|---|---|
read_memory() fails |
Check HMEM_PROJECT_DIR is absolute path and directory exists |
nvm: node not found |
Use absolute path: which node → use as "command" |
| Hooks not firing (Claude Code) | Restart Claude Code. Check ~/.claude/settings.json has all 4 hooks |
| Hooks not firing (Pi) | Known issue — Pi hook integration is currently broken. Use hmem checkpoint manually as a workaround |
| Exchanges not logged | Check HMEM_AGENT_ID matches your Agents/ directory name |
| Sync fails | Run npx hmem-sync connect to re-authenticate |
Updating
npm update -g hmem # MCP server + SDK
npm update -g hmem-sync # Sync (if installed)
npx hmem update-skills # Refresh skill files
License
MIT
hmem MCP questions
How do I add hmem MCP to Claude Code?
Run claude mcp add hmem -- npx -y hmem-mcp in your terminal. Add --scope user to make it available in every project.
How do I add hmem MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does hmem MCP provide?
It exposes 25 tools, including hmem, hmem-curate, read_memory, write_memory, append_memory.
What does hmem give an AI agent?
It provides persistent memory across sessions, devices and AI providers, storing project knowledge in a 5-level hierarchical tree. A single load_project call returns a briefing for about 3000 tokens.
How does the 5-level lazy loading work?
Level 1 one-line summaries load first, and Levels 2 through 5 are fetched only when detail is needed. Full original text is kept in the deeper levels.
What storage does hmem use?
It is backed by SQLite with FTS5 full-text search, and search matches are attributed to the right sub-nodes.
How many MCP tools does hmem expose?
There are two MCP servers: a daily-use hmem server with 13 tools and an opt-in hmem-curate maintenance server with 11 destructive tools.
Can I use hmem in my own code?
Yes, it ships as a documented TypeScript SDK exposing HmemStore, openCompanyMemory and searchMemory.