All plugins

nexus

Self-hosted long-term memory on Qdrant: automatic per-turn prefetch and write-back, plus recall/remember/forget, guardrail rules and a knowledge graph; Hermes and any MCP-connected agent share one collection. Embeddings run fully local by default (sentence-transformers with Qwen/Qwen3-Embedding-0.6B, 1024d, about 1.2 GB from Hugging Face on first use; on Apple Silicon the model is pinned to the CPU, because PyTorch's MPS backend aborts the whole process under two overlapping encodes). A cloud embedder runs only when NEXUS_EMBEDDING_PROVIDER names it and its key is present, and a key that merely sits in the environment never selects one. Shared rooms are handled by observation, not by chat type: a room turns shared as soon as a human other than the owner has written in it, bots never count, and recall, the tools and the graph then serve public memories only. A memory whose text sat in a legacy text field still reaches the injected block (the block falls back from content), and a short state fact marked by the write gate (a version, a count, an amount) needs 12 characters instead of 40, so "Hermes version: 0.23.1" is no longer filtered out. The write gate recognises state values: a long text stores unchanged but comes back with a hint to keep the value as its own short fact, no second write, no automatic extraction. The owner is identified per platform through owner_user_ids. Access levels fail closed: a memory, a protection rule or a graph label without a known level counts as the most restrictive. A local service on 127.0.0.1:9122 serves embeddings and the full MCP toolset; its /embed and /mcp routes demand a per-installation key (service_auth.key, mode 0600) and reject non-loopback Host/Origin, while the open /healthz answers liveness only. The plugin starts that service when Hermes cannot load the embedding stack, and it keeps running afterwards. Session-end fact extraction sends conversation text to the model endpoint from Hermes config.yaml, and the consolidation daemon to its configured model, which defaults to Hermes's own default model through local Ollama; reads ~/.hermes/.env and config.yaml; state and daily backups under ~/.nexus-memory; NEXUS_UPDATE_CHECK=1 opts into a GitHub release check. Disclosure — when Hermes cannot load the embedding stack (and always on Apple Silicon unless NEXUS_EMBED_IN_HOST=1), the plugin starts nexus-memory serve on 127.0.0.1:9122 (embeddings, the full Nexus MCP toolset and a consolidation daemon that sends memory text to the Ollama endpoint at 127.0.0.1:11434 or NEXUS_OLLAMA_BASE under the model named by NEXUS_CONSOLIDATION_MODEL, nexus-memory.consolidation_model or Hermes's model.default, which can be an Ollama cloud model), and the service keeps running after Hermes exits; its /embed and MCP routes require a per-install key in ~/.nexus-memory/service_auth.key (0600) and a loopback Host/Origin; session-end fact extraction sends conversation text to the model endpoint in Hermes config.yaml, and the opt-in recall reranker (nexus-memory.rerank or NEXUS_RERANK=1) defaults to sending each query plus up to 20 memory snippets to that same endpoint using the provider API key it reads from config.yaml; reads ~/.hermes/.env and config.yaml, and opens Hermes's state.db read-only for the session's chat type when the host reports no message author; the shared-room rule records the owner id in <hermes_home>/nexus/config.json (taken from the first gateway user when owner_user_ids is unset) and shared chat ids with a hashed author id in <hermes_home>/nexus/chat-sharing.json; a keyword (SQLite FTS5) copy of memory text and metadata, private memories included, in <hermes_home>/state/nexus-fts.db (or NEXUS_FTS_DB); state, daily backups, a write log without private content and the plugin's own service key (agent_keys/hermes.key, 0600, obtained once from the local service's loopback-only /enroll) under ~/.nexus-memory; the per-turn recall block holds at most three entries and leaves out session and entity hits. Every recall writes one line to ~/.nexus-memory/logs/read-YYYY-MM-DD.jsonl (timestamp, agent, hit count, memory ids, a hash of the query, never the query or memory text; rotated after 90 days, and a failed log never fails a recall). The write gate recognises dictated residue (filler words, word repeats, no closing punctuation) by five weighted signals and stores it as session instead of rule, word for word; a rule confirmed at a terminal is left alone; opt-in NEXUS_UPDATE_CHECK=1 adds a GitHub release check and an upgrade nudge to the system prompt. At session end the plugin reports that session's failed tool calls (tool name, up to 2,000 characters of error text each, at most 50, and the session id; never the conversation) to the Nexus service's POST /events at 127.0.0.1:9122 or NEXUS_SERVICE_URL with its service key, where they are journaled in ~/.nexus-memory/events and the nightly learning may turn a failure that recurs across sessions into a stored lesson; NEXUS_REPORT_INCIDENTS=0 turns this off.

Neboy723Memoryv0.22.65Updated 7 hours ago

About

Self-hosted long-term memory on Qdrant: automatic per-turn prefetch and write-back, plus recall/remember/forget, guardrail rules and a knowledge graph; Hermes and any MCP-connected agent share one collection. Embeddings run fully local by default (sentence-transformers with Qwen/Qwen3-Embedding-0.6B, 1024d, about 1.2 GB from Hugging Face on first use; on Apple Silicon the model is pinned to the CPU, because PyTorch's MPS backend aborts the whole process under two overlapping encodes). A cloud embedder runs only when NEXUS_EMBEDDING_PROVIDER names it and its key is present, and a key that merely sits in the environment never selects one. Shared rooms are handled by observation, not by chat type: a room turns shared as soon as a human other than the owner has written in it, bots never count, and recall, the tools and the graph then serve public memories only. A memory whose text sat in a legacy text field still reaches the injected block (the block falls back from content), and a short state fact marked by the write gate (a version, a count, an amount) needs 12 characters instead of 40, so "Hermes version: 0.23.1" is no longer filtered out. The write gate recognises state values: a long text stores unchanged but comes back with a hint to keep the value as its own short fact, no second write, no automatic extraction. The owner is identified per platform through owner_user_ids. Access levels fail closed: a memory, a protection rule or a graph label without a known level counts as the most restrictive. A local service on 127.0.0.1:9122 serves embeddings and the full MCP toolset; its /embed and /mcp routes demand a per-installation key (service_auth.key, mode 0600) and reject non-loopback Host/Origin, while the open /healthz answers liveness only. The plugin starts that service when Hermes cannot load the embedding stack, and it keeps running afterwards. Session-end fact extraction sends conversation text to the model endpoint from Hermes config.yaml, and the consolidation daemon to its configured model, which defaults to Hermes's own default model through local Ollama; reads ~/.hermes/.env and config.yaml; state and daily backups under ~/.nexus-memory; NEXUS_UPDATE_CHECK=1 opts into a GitHub release check. Disclosure — when Hermes cannot load the embedding stack (and always on Apple Silicon unless NEXUS_EMBED_IN_HOST=1), the plugin starts nexus-memory serve on 127.0.0.1:9122 (embeddings, the full Nexus MCP toolset and a consolidation daemon that sends memory text to the Ollama endpoint at 127.0.0.1:11434 or NEXUS_OLLAMA_BASE under the model named by NEXUS_CONSOLIDATION_MODEL, nexus-memory.consolidation_model or Hermes's model.default, which can be an Ollama cloud model), and the service keeps running after Hermes exits; its /embed and MCP routes require a per-install key in ~/.nexus-memory/service_auth.key (0600) and a loopback Host/Origin; session-end fact extraction sends conversation text to the model endpoint in Hermes config.yaml, and the opt-in recall reranker (nexus-memory.rerank or NEXUS_RERANK=1) defaults to sending each query plus up to 20 memory snippets to that same endpoint using the provider API key it reads from config.yaml; reads ~/.hermes/.env and config.yaml, and opens Hermes's state.db read-only for the session's chat type when the host reports no message author; the shared-room rule records the owner id in <hermes_home>/nexus/config.json (taken from the first gateway user when owner_user_ids is unset) and shared chat ids with a hashed author id in <hermes_home>/nexus/chat-sharing.json; a keyword (SQLite FTS5) copy of memory text and metadata, private memories included, in <hermes_home>/state/nexus-fts.db (or NEXUS_FTS_DB); state, daily backups, a write log without private content and the plugin's own service key (agent_keys/hermes.key, 0600, obtained once from the local service's loopback-only /enroll) under ~/.nexus-memory; the per-turn recall block holds at most three entries and leaves out session and entity hits. Every recall writes one line to ~/.nexus-memory/logs/read-YYYY-MM-DD.jsonl (timestamp, agent, hit count, memory ids, a hash of the query, never the query or memory text; rotated after 90 days, and a failed log never fails a recall). The write gate recognises dictated residue (filler words, word repeats, no closing punctuation) by five weighted signals and stores it as session instead of rule, word for word; a rule confirmed at a terminal is left alone; opt-in NEXUS_UPDATE_CHECK=1 adds a GitHub release check and an upgrade nudge to the system prompt. At session end the plugin reports that session's failed tool calls (tool name, up to 2,000 characters of error text each, at most 50, and the session id; never the conversation) to the Nexus service's POST /events at 127.0.0.1:9122 or NEXUS_SERVICE_URL with its service key, where they are journaled in ~/.nexus-memory/events and the nightly learning may turn a failure that recurs across sessions into a stored lesson; NEXUS_REPORT_INCIDENTS=0 turns this off.

Nexus Memory — Hermes Agent Plugin

A Hermes Agent MemoryProvider plugin for Nexus Memory — a self-hosted memory
layer for AI agents built on Qdrant (vector store).

What This Is

This plugin gives Hermes Agent native memory persistence. It speaks directly to
Qdrant (default http://localhost:6333) using the qdrant_client library —
not through the MCP server. It reuses the same nexus collection and the
same embedding logic, so Hermes and any MCP-connected agent (Claude Code,
Cursor, etc.) see the same memories.

What Leaves Your Machine

Nothing, out of the box — but "out of the box" means no key present. A
fresh install on a machine with no embedding key runs entirely locally:
embeddings use a local model — HuggingFace via sentence-transformers
(installed with the package; default model Qwen/Qwen3-Embedding-0.6B).
Ollama is used only when it is chosen explicitly; it is never required.
Query rewriting and paid stations are off, and Qdrant plus all state
stay local under ~/.nexus-memory.

Cloud embedding is opt-in and needs two things: an explicit choice —
NEXUS_EMBEDDING_PROVIDER=openai|google|jina or embedding_provider in
the Nexus config — and the matching API key in the environment. A key that
is merely present (for example OPENAI_API_KEY, which many setups carry for
other tools) does not select a cloud provider on its own, and turn text is
never sent to one until you have made that choice.

Read the table below before opting in — it lists what each setting enables.

Egress paths, per setting

SettingWhat leaves the machineDestination
NEXUS_EMBEDDING_PROVIDER=openai and OPENAI_API_KEYTurn text (user + assistant), for embeddingOpenAI (api.openai.com)
NEXUS_EMBEDDING_PROVIDER=openai and OPENAI_API_KEYTurn text, for embeddingOpenAI (api.openai.com)
NEXUS_EMBEDDING_PROVIDER=google and GOOGLE_API_KEYTurn text, for embeddingGoogle (generativelanguage.googleapis.com)
NEXUS_EMBEDDING_PROVIDER=jina and JINA_API_KEYTurn text, for embeddingJina (api.jina.ai)
NEXUS_REWRITE=1The search query, for rewritingThe rewrite station (Ollama, local first)
NEXUS_FUEL_PAID=1 + provider keysConsolidation promptsThe configured fuel stations
Session end / entity extractionConversation text, for fact extractionThe model endpoint in the Hermes config.yaml

Embedding is auto-detected, and the automatic path is local: HuggingFace via
sentence-transformers (ships with the package, model Qwen/Qwen3-Embedding-0.6B,
1024d) — no key and no extra software, and no Ollama needed. Ollama is used only
when it is chosen explicitly (NEXUS_EMBEDDING_PROVIDER=ollama); its model
remains qwen3-embedding (1024d). Cloud providers (OpenAI → Google →
Jina) are never picked automatically — they need NEXUS_EMBEDDING_PROVIDER
plus the matching key.

Files this plugin reads

  • ~/.hermes/config.yaml — the model endpoint for session-end extraction.
  • ~/.hermes/.env — provider API keys, read from the process environment
    first (Hermes loads this file at startup). A key is only ever paired with the
    endpoint it belongs to: an OPENAI_API_KEY is never sent to a non-OpenAI
    base_url (see src/nexus_memory/llm_endpoint_config.py).

Files this plugin writes

  • ~/.nexus-memory/ — memory state, backups, toggle files, spend records.

Opt-In Network Calls

Both are off by default and only run when explicitly enabled:

  • Query rewriting (NEXUS_REWRITE=1): rewrites a search query before
    embedding so keyword+vector search finds it. Sends the query to the rewrite
    station. Under the provider this is opt-in only; the MCP server keeps its own
    default, so the two deployments can differ.
  • Paid fuel stations (NEXUS_FUEL_PAID=1, or the dashboard toggle): lets
    consolidation use providers that cost money. Until opted in, only free/local
    stations are used — provider keys are never spent on their own, and no file is
    written during import.

How to Activate

hermes memory setup

Select nexus from the provider list. The wizard will guide you through
configuration.

Config Fields

FieldDescriptionRequiredDefault
qdrant_urlQdrant server URLNohttp://localhost:6333

| collection_name | Qdrant collection name | No | nexus |

Shared Store

This plugin and the Nexus Memory MCP server share the same Qdrant
collection
. Everything written by the plugin is visible to the MCP server,
and vice versa. Claude Code, Cursor, and Hermes Agent all operate on one
unified memory.

Exposed Tools

  • nexus_recall — Search past memories, facts, and context
  • nexus_remember — Store a memory for future recall
  • nexus_forget — Delete a memory by ID

Failed tool calls, reported at session end (0.22.64)

The nightly learning in Nexus reads no harness session store. Instead every
agent reports its own failed tool calls to POST /events, and Nexus decides
what becomes a lesson. This provider does that at the end of a session: it
takes the tool results Hermes itself marked as failed (exit_code != 0 or a
set error), and sends tool name, error text and session id — never the
conversation.

NEXUS_REPORT_INCIDENTS=0 turns it off. If the service is not reachable, the
report is skipped silently; a session end never waits on it.

README from the reviewed commit 526ef84; 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