Native memory provider for Hermes v0.7.0+. Context Bundle loads at startup when available, relevant knowledge surfaces before every turn, and Hermes captures cleaned transcript turns into Mem threads.

For your agent

Give this line to your agent. It should use the universal install skill first; this page remains the behavior and troubleshooting reference:

Read https://mem.nowledge.co/SKILL.md and follow the instructions to install or update Nowledge Mem for Hermes Agent. Verify with nmem status and the Context Bundle or Working Memory check, then summarize what changed.

One-command setup (plugin)

bash <(curl -sL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.sh)

Windows PowerShell

irm https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.ps1 | iex

Plugin-Native

Hermes v0.7.0+ supports memory providers. Install the plugin once for built-in behavior: Context Bundle loads at session start when available, relevant memories surface before each turn, and Hermes captures cleaned transcript turns into Mem threads while the conversation runs. No SOUL.md guidance needed.

Standalone Provider

Hermes keeps new memory providers outside the core hermes-agent repository. The installer on this page is the supported Nowledge Mem path: it places the provider in ~/.hermes/plugins/nowledge-mem/, where Hermes loads it through the same memory-provider lifecycle.

Your cross-tool knowledge, accessible in every Hermes session. Decisions from Claude Code, preferences from Cursor, insights from ChatGPT: one knowledge graph, always available.

Your first success state

Install the plugin, restart Hermes, and start a new session. Send one short message that includes a unique phrase, then cleanly exit, run /new, or run /reset. nmem t search "that phrase" --source hermes should find the captured Hermes thread. If your Mem library already has memories, also ask "what decisions have I made recently?" and Hermes should search your knowledge graph without you pointing it at a tool.

Have older Hermes sessions?

The plugin captures new Hermes sessions as they run. To import conversations that already exist in ~/.hermes/state.db, run a historical sync from the machine where Hermes is installed:

nmem t sync --from hermes          # preview only
nmem t sync --from hermes --apply  # import into Mem

This is the right path for remote Mem too: your laptop reads the local Hermes database, then uploads normalized threads to the Mem server configured in nmem status.

Before You Start

Nowledge Mem running locally (installation) or a reachable remote server
Hermes Agent v0.7.0+ installed (v0.6.x works with MCP mode)
nmem CLI available in PATH. If the desktop app is on this machine, use Settings → Preferences → Developer Tools → Install CLI. On a remote-only machine, install it with pip install nmem-cli.

nmem status       # Nowledge Mem is running
hermes --version  # Hermes is available

Setup

Plugin install (recommended)

bash <(curl -sL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.sh)

Installs the native memory provider plugin. Restart Hermes after running.

On Windows, use the native PowerShell installer; Git Bash and WSL are not required:

irm https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.ps1 | iex

Or install manually:

Copy plugin files to ~/.hermes/plugins/nowledge-mem/:

mkdir -p ~/.hermes/plugins/nowledge-mem
cd ~/.hermes/plugins/nowledge-mem
for f in plugin.yaml __init__.py provider.py client.py; do
  curl -sLO "https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/$f"
done

Set the provider in ~/.hermes/config.yaml:
```
memory:
  provider: "nowledge-mem"
```
Restart Hermes.

MCP mode (Hermes < v0.7.0)

If you are on an older version of Hermes or prefer a standard MCP connection:

bash <(curl -sL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.sh) --mcp

Windows PowerShell

& ([scriptblock]::Create((irm https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.ps1))) -Mcp

This adds the MCP server to config.yaml and installs behavioral guidance in ~/.hermes/SOUL.md. Tools appear with the mcp_nowledge_mem_ prefix.

Without behavioral guidance, MCP mode gives Hermes tools but no instruction on when to use them proactively. If Hermes recalls but never saves, this is usually why. The plugin mode does not need guidance because behavior is built into the provider lifecycle.

Verify

First verify thread capture with an empty-library-safe check. In Hermes, send:

Please reply with: hermes nmem smoke test

Then exit cleanly, run /new, or run /reset so Hermes performs its final thread flush. In a terminal, check:

nmem t search "hermes nmem smoke test" --source hermes

You should see the Hermes thread. After that, if your Mem library already has memories, ask Hermes something that depends on past work:

What decisions have I made recently?

In plugin mode, Hermes should call nmem_search. In MCP mode, it should call mcp_nowledge_mem_memory_search. Then ask Hermes to save a conclusion or watch whether it chooses the native nmem_save tool when the conversation reaches a durable decision.

What Happens Automatically

The plugin hooks into Hermes' memory provider lifecycle. No manual tool calls needed for these:

Context Bundle loads at the start of every session when available, with Working Memory fallback on older CLIs
Relevant memories surface before each turn (proactive recall)
User profile facts from Hermes sync to your cross-tool knowledge graph
Session transcripts are captured into Mem threads as turns complete, with a final delta flush when Hermes exits, starts a new session, or resets cleanly
Compression recovery hint is provided on Hermes builds that consume provider compression output

In MCP mode, these behaviors depend on the SOUL.md guidance and are not guaranteed.

Hermes Memory vs Nowledge Mem

Hermes has a built-in memory system for facts specific to Hermes sessions. Nowledge Mem is complementary: it stores knowledge that spans tools. Use both:

Hermes memory: Hermes-specific preferences, environment details, tool quirks
Nowledge Mem: Decisions, procedures, and learnings that future sessions in any tool should know about

The plugin automatically mirrors user profile facts from Hermes to Nowledge Mem, so cross-tool knowledge stays in sync.

What You Can Do

Find knowledge from other tools. Ask "what did we decide about the database?" and Hermes searches across decisions you made in Claude Code, insights from ChatGPT, notes from Cursor.

Save knowledge for everywhere. When you reach a conclusion in Hermes, it saves to your knowledge graph so your next Claude Code session, Cursor project, or ChatGPT conversation can find it too.

Search past conversations. Find past conversations by keyword across every tool. Retrieve the full exchange with pagination.

Keep Hermes sessions searchable. The provider captures cleaned user / assistant turns into a Mem thread while the conversation runs. A clean exit, /new, or /reset performs a final delta flush. The first write for each Hermes session_id imports the thread; later writes for the same session append only the new turns.

Backfill older Hermes sessions. Historical Hermes conversations live in ~/.hermes/state.db. Run nmem t sync --from hermes to preview them, then add --apply to import. The command is safe to rerun: it reuses Hermes session_id as the Mem thread ID and appends with message deduplication.

In MCP mode, you also get graph exploration tools to trace how decisions evolved and discover related memories.

Tools

Plugin mode uses clean nmem_ names. MCP mode uses the mcp_nowledge_mem_ prefix.

Plugin	MCP mode tool name	Purpose
`nmem_search`	`mcp_nowledge_mem_memory_search`	Search memories
`nmem_save`	`mcp_nowledge_mem_memory_add`	Save or upsert a decision, insight, or learning
`nmem_update`	`mcp_nowledge_mem_memory_update`	Refine an existing memory
`nmem_delete`	`mcp_nowledge_mem_memory_delete`	Remove one or more memories
`nmem_thread_search`	`mcp_nowledge_mem_thread_search`	Search past conversations
`nmem_thread_messages`	`mcp_nowledge_mem_thread_fetch_messages`	Fetch messages from a thread

MCP mode also includes list_memory_labels, memory_neighbors, and memory_evolves_chain. These will be added to the plugin when the nmem CLI supports them.

Configuration

No configuration needed for local use. The plugin uses the shared nmem client config for server URL and API key. Normal memory operations go through nmem; long transcript payloads are sent directly to the Mem API.

If the Nowledge Mem desktop app is on the same machine, nmem is already bundled. For remote-only setups without the desktop app: pip install nmem-cli.

Remote access

Configure the local nmem client to point at your remote server:

nmem config client set url https://your-server
nmem config client set api-key your-key

This updates the client-side connection settings for the machine running Hermes. It is separate from server-side Access Anywhere or LAN bind configuration on the Mem host.

The only plugin-specific setting is request timeout, in ~/.hermes/nowledge-mem.json:

{
  "timeout": 60
}

Spaces

Hermes supports three clean mapping levels:

space: one fixed lane for this Hermes profile
space_by_identity: a small explicit map from Hermes identities to named spaces
space_template: one derived lane per Hermes identity, for example agent-{identity}

If none of those are set, Hermes can still inherit NMEM_SPACE.

For MCP mode, update the URL directly in config.yaml:

~/.hermes/config.yaml

mcp_servers:
  nowledge-mem:
    url: "https://your-server/mcp"
    headers:
      Authorization: "Bearer your-key"
    timeout: 120

See Access Mem Anywhere.

Update

Use the same mode you installed with:

Plugin mode, the default for Hermes v0.7.0+: re-run the setup command without flags, then restart Hermes.
MCP mode, for Hermes v0.6.x or a deliberate standard MCP setup: re-run the setup command with --mcp, then restart Hermes.

# Plugin mode
bash <(curl -sL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.sh)

# MCP mode
bash <(curl -sL https://raw.githubusercontent.com/nowledge-co/community/main/nowledge-mem-hermes/setup.sh) --mcp

The MCP tools themselves are served by Nowledge Mem and update with the desktop app. The Hermes plugin files update through the setup script.

After updating, the script prints the version and endpoint from the files Hermes will load:

Installed version: 0.5.18
Thread import endpoint: /threads/import

If those lines still show an old version or a different endpoint, Hermes is reading a different HERMES_HOME. Set HERMES_HOME to the profile you use to launch Hermes, run the setup command again, then restart Hermes.

Disable or Roll Back

Quit Hermes before changing files.

Plugin mode: set memory.provider in ~/.hermes/config.yaml back to your previous provider, or remove that line if you did not use Hermes memory before. Then remove ~/.hermes/plugins/nowledge-mem. On older Hermes builds that needed a compatibility copy, also remove ~/.hermes/hermes-agent/plugins/memory/nowledge-mem.
MCP mode: remove the mcp_servers.nowledge-mem block from ~/.hermes/config.yaml. If you no longer want the behavior guidance, remove the section headed # Nowledge Mem for Hermes from ~/.hermes/SOUL.md.
Restart Hermes and run hermes --version plus nmem status to confirm the host and Mem client are still healthy.

Customize Safely

Use Hermes' own guidance files, not the installed plugin directory:

~/.hermes/SOUL.md for personal default behavior across sessions
HERMES.md at the project root for repo-specific rules

Do not patch the installed Nowledge Mem plugin files under ~/.hermes/plugins/. For the full host-by-host map, see Customize Integration Behavior.

Troubleshooting

Cannot connect to Nowledge Mem. Confirm the server is running with nmem status. Check that the URL matches the address shown by nmem status.

Hermes recalls but never saves durable memories (MCP mode). Behavioral guidance is missing. Run the setup command, then restart Hermes. The guidance must be in ~/.hermes/SOUL.md (always loaded) or a HERMES.md at the git root. In plugin mode, recall and transcript capture are built into the provider lifecycle and do not depend on guidance.

Hermes threads are not appearing in Mem. The provider captures completed turns and also flushes at real session boundaries. Test with a normal completed turn, then try a clean exit, /new, or /reset. If Hermes is killed abruptly during a turn, that unfinished turn may never reach the provider.

An agent says client.py differs from community/main. That usually means Hermes is running a stale local plugin copy. Re-run the plugin setup command, confirm it prints Thread import endpoint: /threads/import, and restart Hermes. Use SOUL.md or HERMES.md for custom behavior instead of editing files under ~/.hermes/plugins/nowledge-mem/.

Older Hermes sessions are missing. This is expected until you run a historical import. The desktop watcher does not read Hermes' SQLite database. Run nmem t sync --from hermes to preview older sessions from ~/.hermes/state.db, then run nmem t sync --from hermes --apply when the preview looks right.

Tools not appearing (plugin). Confirm memory.provider: "nowledge-mem" in config.yaml and plugin files exist in ~/.hermes/plugins/nowledge-mem/. Restart Hermes.

Tools not appearing (MCP). Confirm the mcp_servers.nowledge-mem block in config.yaml. Restart Hermes. Verify the YAML is valid (correct indentation, no tabs).

Slow responses. Default timeout is 30 seconds. Increase in nowledge-mem.json (plugin) or config.yaml (MCP). If the issue persists, check nmem status for server health.

Connectors overview
Claude Code · OpenCode · Pi · OpenClaw · Alma · Bub
Source: nowledge-mem-hermes

Hermes Agent × Nowledge Mem