# hermes-memory-installer Recent Update: Auto-Repair for Targeted gbrain Missing Embeddings > Source: > Published: 2026-07-16 00:00:59+00:00 If you've been working with cognitive architectures that rely on structured memory injection, you likely know the pain of corrupted or incomplete embedding spaces. The latest update to `hermes-memory-installer` directly addresses a brittle failure mode: missing embeddings in the gbrain module. This fix introduces an automatic, targeted repair mechanism that detects and rebuilds only the affected subset of embeddings, rather than triggering a full reinstall. Here’s what changed, why it matters, and how to benefit from it. In a typical setup, `hermes-memory-installer` populates the gbrain—a specialized long-term memory store—with precomputed embeddings for core concepts, episodic traces, and procedural patterns. These embeddings are the numeric backbone that allows the agent to query, retrieve, and associate memories efficiently. However, under certain conditions—partial upgrades, concurrent memory imports, or incomplete network transfers—the gbrain’s embedding table ended up with holes. Specific embeddings for targeted contexts were simply missing. The agent would still boot, but retrieval quality degraded silently: queries returned null vectors or fell back to generic responses, breaking fine-grained recall. Users reported that their agents "forgot" recent conversations or failed to recognize learned skills, yet no obvious error was raised. Previously, the only remedy was a full reinstall of the memory installer, which wiped and rebuilt the entire gbrain. That was slow, wasteful, and could erase customized embeddings that were working correctly. The new update (`v2.1.0` onwards) adds a dedicated repair pass during the installation and upgrade routine. Instead of scanning the entire gbrain, the installer now maintains a lightweight manifest of expected embedding keys for each memory context. During setup, it checks the actual embedding store against this manifest. If any keys are missing, it triggers a selective rebuild: only the missing embeddings are regenerated and inserted, while existing, valid embeddings remain untouched. This is far more efficient. A full reinstall could take minutes and reprocess hundreds of embeddings; the targeted repair often completes in sub-second time for small gaps. More importantly, it preserves user-added or fine-tuned embeddings that may exist alongside the core set. The repair logic lives in the `repair_gbrain()` method, invoked automatically at the end of the installation pipeline. The installer loads the manifest JSON, which lists every expected embedding key along with its source text and model version. It then queries the gbrain storage backend (by default, a local vector store) for each key. If a key is absent, it calls the embedding model to generate a new vector and stores it. Here’s a simplified snippet showing the core loop: ``` python def repair_gbrain(gbrain_store, manifest_path, embed_model): with open(manifest_path) as f: manifest = json.load(f) missing_keys = [] for entry in manifest["embeddings"]: key = entry["key"] if not gbrain_store.exists(key): missing_keys.append(entry) if not missing_keys: logger.info("gbrain is intact, no repair needed") return logger.warning(f"Found {len(missing_keys)} missing embeddings, repairing...") for entry in missing_keys: text = entry["source"] vector = embed_model.encode(text) gbrain_store.upsert(entry["key"], vector, metadata=entry.get("meta", {})) gbrain_store.commit() logger.info(f"Repaired {len(missing_keys)} embeddings") ``` The function is intentionally minimal—it relies on the manifest being accurate and the embedder being available. In practice, the real code also handles batching, status callbacks, and rollback on failure, but this captures the essence. The repair runs in three scenarios: `hermes-memory-installer` , the new manifest may contain additional or changed embedding keys. The installer compares the old and new manifests and repairs any gaps.`--repair-gbrain` to the installer command. This is useful if you suspect manual corruption or have restored a gbrain from backup.Crucially, the repair does not overwrite existing embeddings that match the manifest. If you deliberately altered an embedding (e.g., to tune a concept), it remains untouched—as long as the key exists. For anyone building agents with persistent memory, this update removes a significant source of silent reliability loss. You no longer need to monitor for degraded recall or schedule maintenance windows for full rebuilds. The auto-repair integrates into your existing deploy pipeline, ensuring the gbrain stays consistent across updates. A few practical notes: The code example above can be adapted for your own tooling if you need to perform similar repairs outside of the official installer. Targeted auto-repair is a quality-of-life improvement that aligns with the principle of least surprise: your agent should just work, even when the embedding layer has been briefly corrupted. `hermes-memory-installer` now bakes this resilience in by default. If you've been deferring an upgrade because of the full-reinstall tax, there's no better time. The fix is live in the current release. Run your installer with `--check-repair` to verify against your existing gbrain, or just let it do its thing on the next update. Memory should be robust. Now it is.