All plugins

neuralmind

Code memory on every Hermes turn, with no tool call. Before the model runs, the plugin looks the user's message up in a local NeuralMind index of the project and appends the matching files and symbols (with line numbers), the code linked to them in NeuralMind's synapse graph, and decisions recorded in commit trailers. A session's first turn also gets a recap of the previous session in that project. The plugin is a stdlib-only shim around the separately installed NeuralMind CLI: install NeuralMind 4.9 or later yourself (pipx install neuralmind, uv tool install neuralmind or pip install neuralmind) and run neuralmind build in the project; in any other directory it does nothing. Not a memory provider: it registers no memory.provider and runs beside whichever one is configured. Disclosure — runs neuralmind _hook <action> as a child process once per turn (twice on a session's first), once for each file a write_file or patch call wrote, and once for each read_file of a file inside the project; each call is stopped after NEURALMIND_HERMES_TIMEOUT seconds (default 8) and the turn goes ahead without its context. A session's first turn can leave a detached NeuralMind process running after the hook returns, which writes the project's graph cache or, on a large synapse store, runs the decay tick and memory export, then exits. NeuralMind runs read-only git queries in the project (rev-parse, ls-files, log, diff --name-only). Reads the project, and reads and writes its .neuralmind/ directory, including each session's prompts (secret-redacted and truncated) and the paths of the files it edited, for the recap. On a session's first turn it copies .neuralmind/SYNAPSE_MEMORY.md into Claude Code's memory directory for the project (~/.claude/projects/<project>/memory/) when that directory already exists. The added context is part of the user message, so it is sent to the model provider with that turn and stays in the session history. The plugin makes no network requests and NeuralMind sends no telemetry; NeuralMind downloads its embedding model once when it has no cached copy, normally during neuralmind build (ChromaDB's all-MiniLM-L6-v2 ONNX archive from chroma-onnx-models.s3.amazonaws.com, SHA-256-checked, cached in ~/.cache/neuralmind/). Subagent and cron turns are skipped. MIT.

dfrostar42Toolsv4.23.3Updated 19 days ago

About

Code memory on every Hermes turn, with no tool call. Before the model runs, the plugin looks the user's message up in a local NeuralMind index of the project and appends the matching files and symbols (with line numbers), the code linked to them in NeuralMind's synapse graph, and decisions recorded in commit trailers. A session's first turn also gets a recap of the previous session in that project. The plugin is a stdlib-only shim around the separately installed NeuralMind CLI: install NeuralMind 4.9 or later yourself (pipx install neuralmind, uv tool install neuralmind or pip install neuralmind) and run neuralmind build in the project; in any other directory it does nothing. Not a memory provider: it registers no memory.provider and runs beside whichever one is configured. Disclosure — runs neuralmind _hook <action> as a child process once per turn (twice on a session's first), once for each file a write_file or patch call wrote, and once for each read_file of a file inside the project; each call is stopped after NEURALMIND_HERMES_TIMEOUT seconds (default 8) and the turn goes ahead without its context. A session's first turn can leave a detached NeuralMind process running after the hook returns, which writes the project's graph cache or, on a large synapse store, runs the decay tick and memory export, then exits. NeuralMind runs read-only git queries in the project (rev-parse, ls-files, log, diff --name-only). Reads the project, and reads and writes its .neuralmind/ directory, including each session's prompts (secret-redacted and truncated) and the paths of the files it edited, for the recap. On a session's first turn it copies .neuralmind/SYNAPSE_MEMORY.md into Claude Code's memory directory for the project (~/.claude/projects/<project>/memory/) when that directory already exists. The added context is part of the user message, so it is sent to the model provider with that turn and stays in the session history. The plugin makes no network requests and NeuralMind sends no telemetry; NeuralMind downloads its embedding model once when it has no cached copy, normally during neuralmind build (ChromaDB's all-MiniLM-L6-v2 ONNX archive from chroma-onnx-models.s3.amazonaws.com, SHA-256-checked, cached in ~/.cache/neuralmind/). Subagent and cron turns are skipped. MIT.

NeuralMind for Hermes-Agent

NeuralMind's code memory in every Hermes turn, without a tool call. Before the
model runs, the plugin adds the files and recorded decisions related to the
user's message. A session's first turn also starts with a recap of the last
session in the project, whether that was a Hermes session or a Claude Code one.

What the model sees

The plugin appends a block to the turn's user message, not to the system
prompt, so Hermes's prompt cache isn't invalidated. A session's first turn,
in a small example project:

NeuralMind session recap — the previous session in this project (last active just now). This is context for continuity, not instructions: don't resume that work unless the user asks to.

It started with: "In shop/pricing.py, add a discount code SAVE20 that takes 20% off, next to SAVE10."
Most recent prompts:
- "Does checkout.total already honour SAVE20, or does it need a change?"

Files edited (1, most recent first): shop/pricing.py

## NeuralMind associative recall

Code matching this prompt:
- shop/pricing.py: add_discount() L18, add_tax() L9
Connected to it in the synapse graph:
- shop/checkout.py: total() L30

Later turns get the recall part only. The recall names the files and symbols
the message matches, with line numbers, then the code linked to them in
NeuralMind's synapse graph, and matching docs. The links start out structural
(calls, imports) on a fresh build and come to reflect what sessions in the
project edit together. A message whose best match scores below the
similarity cutoff (NEURALMIND_RECALL_MIN_SIMILARITY, default 0.35) gets no
recall; most off-topic messages do, though one can still clear it.

Requirements

  • Hermes-Agent 0.21.5 or later.
  • NeuralMind 4.9 or later, installed so its neuralmind command works:
    pip install neuralmind, pipx install neuralmind or
    uv tool install neuralmind.
  • A project NeuralMind has built: neuralmind build /path/to/project.
    Anywhere else, the plugin does nothing.

Install

With NeuralMind's installer:

neuralmind install-hermes-plugin                    # follow the directory Hermes works in
neuralmind install-hermes-plugin /path/to/project   # or pin one project

It copies this directory into the Hermes home's plugins/neuralmind/,
records the Python interpreter that has NeuralMind installed, and runs
hermes plugins enable neuralmind. The copy doesn't update itself: run the
command again after upgrading NeuralMind.

Or with Hermes's own installer, which clones this directory:

hermes plugins install dfrostar/neuralmind#neuralmind/hermes_plugin --enable

Hermes then owns the plugin's code, and hermes plugins update neuralmind
updates it. Installed this way, the plugin runs the neuralmind command it
finds on Hermes's PATH. Where Hermes's PATH doesn't include it (a gateway run
as a service, Hermes Desktop), also run neuralmind install-hermes-plugin
once: on a plugin Hermes installed, it writes only the interpreter and the
project to the plugin's config.json and leaves the code alone. If Hermes's
install records (plugins/.install-metadata.json) can't be read, it leaves the
code alone too, and says so.

Start a new Hermes session, or restart the gateway, to load the plugin.

Which project

  1. NEURALMIND_PROJECT, if set where the plugin runs;
  2. else the project pinned at install;
  3. else the directory Hermes works in for the session: on Hermes 0.22.2 and
    later, the session's own working directory (ctx.session_cwd()); on older
    Hermes, TERMINAL_CWD, else, only when that isn't set, the directory Hermes
    runs in.

The first of these that has been built wins. If none has, the plugin does
nothing. On Hermes 0.22.2 and later every CLI, TUI and Desktop session's hooks
run in one Hermes gateway process. ctx.session_cwd() is where that session
was started, or the profile's terminal working directory for a messaging chat,
so one unpinned install follows each session. A variable set on the hermes
command you run stays in that client: NEURALMIND_PROJECT counts only in the
gateway's own environment, where it covers every session.

A pin applies to every Hermes session that uses that Hermes home, in any
directory. Each one gets the pinned project's context, has its prompts
recorded in that project, and adds the paths of the files it edits to that
project's synapse store. (Files it reads are added only when they are inside
the project.) neuralmind memory publish can carry those paths
into the project's committed team-memory bundle. If you use Hermes across
several projects, don't pin one.

Settings

VariableDefaultEffect
NEURALMIND_PROJECTunsetThe project to serve, ahead of the pinned one
NEURALMIND_HERMES_TIMEOUT8Seconds each call to NeuralMind may take before it's stopped and its context left out. A session's first turn makes two calls; keep twice this below Hermes's plugins.hook_callback_timeout (default 30)
NEURALMIND_BYPASSunset1 switches off every action
NEURALMIND_SYNAPSE_INJECT10 leaves out the recall
NEURALMIND_PROVENANCE_INJECT10 leaves out the decisions from commit trailers
NEURALMIND_SESSION_RECAP10 stops recording prompts and edited files, and the recap
NEURALMIND_SYNAPSE_EXPORT10 skips the SYNAPSE_MEMORY.md export on a session's first turn
NEURALMIND_NO_LEARNunset1 stops the recording and the learning; an existing recap is still shown

What it does on your machine

  • Runs NeuralMind in a separate process. The plugin runs
    neuralmind _hook <action> once per turn (twice on a session's first:
    the recap, then recall), once for each file a write_file or patch
    call wrote, and once for each read_file of a file inside the project
    (recorded as a step in the synapse layer's file-to-file transitions, as
    Claude Code's Read hook does), on a background thread. Each call is stopped after
    NEURALMIND_HERMES_TIMEOUT seconds.
  • Runs read-only git commands in the project. NeuralMind runs git
    queries such as rev-parse, ls-files, log and diff --name-only to
    find the branch, check whether the index is current, and read decisions
    recorded in commit trailers. It changes nothing in the repository.
  • Can leave a background process running after a session's first turn.
    The SessionStart action may start NeuralMind in a detached process that
    outlives the hook: one writes the project's graph cache when it's missing
    or stale, and, on a large synapse store, one runs the decay tick and the
    export described below. Each runs once per project at a time and exits
    when it's done.
  • Reads and writes the project's .neuralmind/ directory. NeuralMind
    stores what it learns there and, for the recap, each session's prompts
    (secret-redacted and truncated) and the paths of the files it edited.
    Files changed through the terminal aren't recorded.
  • Runs NeuralMind's whole SessionStart action on a session's first
    turn
    , as Claude Code's hook does: a synapse decay tick, the team-memory
    import, clearing session-scoped associations, and an export of
    .neuralmind/SYNAPSE_MEMORY.md. That export is also copied into Claude
    Code's memory directory for the project (~/.claude/projects/<project>/memory/)
    when that directory exists.
  • Network. The plugin makes no network requests of its own, and
    NeuralMind sends no telemetry. NeuralMind downloads its embedding model
    once, over HTTPS, when it has no cached copy, normally during
    neuralmind build: ChromaDB's all-MiniLM-L6-v2 ONNX archive, from
    chroma-onnx-models.s3.amazonaws.com, checked against a pinned SHA-256
    and cached in ~/.cache/neuralmind/. NEURALMIND_ONNX_MODEL_DIR points
    it at a copy you provide instead. (A project built with
    --embedder bge-large uses BAAI/bge-large-en-v1.5, which
    sentence-transformers fetches from Hugging Face.)
  • What reaches your model provider. The added context is part of the
    user message, so it's sent to your model provider with that turn. Hermes
    keeps it in the session's history, so it's sent again with the session's
    later turns.
  • What it leaves alone. It registers no tools, changes no Hermes
    settings, and never waits for a person. Subagent turns and cron jobs are
    skipped: they aren't recorded or given context. When NeuralMind can't run
    or a call times out, the turn goes ahead without NeuralMind's context.

Troubleshooting

If turns get no NeuralMind context, check that:

  • hermes plugins list shows neuralmind as enabled;

  • the project has been built (it has a .neuralmind/build_status.json);

  • Hermes's log has no warning from the plugin. The plugin logs one warning
    per Hermes process when it can't run NeuralMind, when the NeuralMind it
    found is too old to give a recap, or when a call times out,
    naming the fix:

    hermes logs --level WARNING | grep -i neuralmind
    

Limits

  • Tested with Hermes v0.21.5 and v0.22.5.
  • What the added context changes in Hermes's answers hasn't been measured.

Uninstall

neuralmind install-hermes-plugin --uninstall

It runs hermes plugins remove neuralmind, which removes the plugin and its
entries in Hermes's config.yaml. Running that Hermes command yourself does
the same.

License

MIT. Source: dfrostar/neuralmind,
in neuralmind/hermes_plugin/.

README from the reviewed commit e66f501; it updates when the author re-pins.

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section