hermes-memanto 0.1.0__tar.gz

hermes_memanto-0.1.0/.env.example

@@ -0,0 +1,12 @@
+# ============================================================================
+# Memanto for Hermes - environment configuration
+# ============================================================================
+# Hermes reads these from $HERMES_HOME/.env (default ~/.hermes/.env). The
+# `hermes memory setup` wizard writes MOORCHEH_API_KEY there for you.
+
+# REQUIRED: Moorcheh API key (https://console.moorcheh.ai/api-keys)
+MOORCHEH_API_KEY=your_key_xxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# OPTIONAL: Override the Memanto agent id (memory namespace).
+# Takes priority over agent_id in $HERMES_HOME/memanto.json.
+# MEMANTO_AGENT_ID=hermes-coder

hermes_memanto-0.1.0/.gitignore

@@ -0,0 +1,106 @@
+# Environment variables and secrets
+.env
+.env.local
+.env.*.local
+*.key
+*.pem
+*.crt
+secrets/
+.secrets
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+uv.lock
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+.venv/
+ENV/
+env/
+.env/
+
+# IDEs
+.vscode/
+.idea/
+.claude/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Testing
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Logs
+logs/
+*.log
+pip-log.txt
+pip-delete-this-directory.txt
+
+# OS
+.DS_Store
+Thumbs.db
+Desktop.ini
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+*.bak
+*.swp
+*.swo
+
+# Generated version file
+**/_version.py

hermes_memanto-0.1.0/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2026 EdgeAI Innovations Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

hermes_memanto-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: hermes-memanto
+Version: 0.1.0
+Summary: Memanto memory-agent provider for the Hermes agent - typed long-term memory (remember/recall/answer) backed by Moorcheh
+Project-URL: Homepage, https://www.memanto.ai
+Project-URL: Documentation, https://docs.memanto.ai
+Project-URL: Repository, https://github.com/moorcheh-ai/memanto
+Project-URL: Bug Tracker, https://github.com/moorcheh-ai/memanto/issues
+Author-email: Memanto <info@memanto.ai>
+License: MIT
+License-File: LICENSE
+Keywords: agent memory,hermes,hermes-agent,memanto,memory provider,moorcheh,semantic memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4,>=3.10
+Requires-Dist: memanto>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8.2.0; extra == 'dev'
+Requires-Dist: ruff<0.15,>=0.14.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Hermes + Memanto: Persistent Memory Agent
+
+This package adds [Memanto](https://memanto.ai) as a **memory agent** for the
+[Hermes agent](https://github.com/NousResearch/hermes-agent). Memanto gives
+Hermes typed long-term memory with confidence and provenance, semantic recall,
+and RAG-style answers, backed by the [Moorcheh](https://moorcheh.ai) vector
+platform.
+
+Unlike a passive "memory layer", every namespace in Memanto is a first-class
+**agent** (`memanto agent create/activate`), so this provider maps one Hermes
+identity to one Memanto agent.
+
+## What you get
+
+- **Auto-recall** — relevant memories are injected before each turn.
+- **Turn capture** — conversation turns are stored as `event` memories.
+- **Explicit tools** — `memanto_remember`, `memanto_recall`, `memanto_answer`.
+- **Memory mirroring** — Hermes' built-in `memory` writes are echoed into Memanto.
+- **Profile isolation** — `agent_id: hermes-{identity}` scopes memory per Hermes profile.
+
+## Why a standalone plugin?
+
+Hermes' built-in providers under `plugins/memory/` are a closed set; new memory
+backends ship as standalone plugins that users install into
+`~/.hermes/plugins/`. Hermes discovers a memory provider as a **directory**
+under `$HERMES_HOME/plugins/<name>/` containing an `__init__.py` that exposes
+`register(ctx)` plus a `plugin.yaml`. This package ships exactly that, plus an
+installer that drops it into place.
+
+## Prerequisites
+
+- Python 3.10+
+- A running [Hermes agent](https://github.com/NousResearch/hermes-agent) install
+- A [Moorcheh API key](https://console.moorcheh.ai/api-keys) (free tier: 100K ops/month)
+
+## Install
+
+```bash
+# 1. Install this package (pulls in the memanto SDK)
+pip install hermes-memanto
+
+# 2. Drop the plugin into your Hermes home (~/.hermes/plugins/memanto/)
+hermes-memanto-install
+
+# 3. Configure your key + select the provider
+export MOORCHEH_API_KEY=...          # https://console.moorcheh.ai/api-keys
+hermes config set memory.provider memanto
+```
+
+`hermes memory setup` will also list **memanto** once the plugin is installed,
+and writes `MOORCHEH_API_KEY` into `~/.hermes/.env` for you.
+
+### From a source checkout
+
+```bash
+git clone https://github.com/moorcheh-ai/memanto.git
+cd memanto/integrations/hermes-agents
+pip install -e .
+hermes-memanto-install            # or: hermes-memanto-install --hermes-home /path/to/.hermes
+```
+
+The installer copies `hermes_memanto/provider.py` verbatim as the plugin's
+`__init__.py`, so the installed plugin is self-contained and only needs the
+`memanto` SDK at runtime (declared in its `plugin.yaml`).
+
+## Configuration
+
+After install, settings live in `$HERMES_HOME/memanto.json`:
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `agent_id` | `hermes-{identity}` | Memanto agent id (memory namespace). `{identity}` expands to the Hermes profile name. |
+| `pattern` | `tool` | Agent pattern used when auto-creating: `support`, `project`, or `tool`. |
+| `auto_recall` | `true` | Inject relevant memories before each turn. |
+| `auto_capture` | `true` | Store cleaned conversation turns as `event` memories. |
+| `auto_create` | `true` | Create the agent on first use if it does not exist. |
+| `mirror_memory_writes` | `true` | Echo Hermes' built-in `memory` writes into Memanto. |
+| `max_recall_results` | `10` | Max memories formatted into prefetch context (1–100). |
+| `min_confidence` | `null` | Drop recalled memories below this confidence (0.0–1.0). |
+| `session_duration_hours` | `null` | Override Memanto session lifetime. |
+
+| Environment variable | Description |
+|----------------------|-------------|
+| `MOORCHEH_API_KEY` | Moorcheh API key (required). |
+| `MEMANTO_AGENT_ID` | Override the agent id (takes priority over the config file). |
+
+## Tools exposed to Hermes
+
+| Tool | Description |
+|------|-------------|
+| `memanto_remember` | Store a durable fact, preference, decision, goal, or instruction. |
+| `memanto_recall` | Search memories by semantic similarity. |
+| `memanto_answer` | Answer a question grounded only in stored memories (RAG). |
+
+Memory types follow Memanto's taxonomy: `fact`, `preference`, `goal`,
+`decision`, `artifact`, `learning`, `event`, `instruction`, `relationship`,
+`context`, `observation`, `commitment`, `error`.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest          # provider unit tests (no network; SdkClient is faked)
+ruff check .
+```
+
+## How it relates to the other integrations
+
+| Integration | Package | What it does |
+|-------------|---------|--------------|
+| `integrations/mcp` | `memanto-mcp` | MCP server for any MCP-compatible client (Claude, Cursor). |
+| `integrations/crewai` | `crewai-memanto` | CrewAI tools for multi-agent memory sharing. |
+| `integrations/hermes-agents` | `hermes-memanto` | **This** — a memory provider for the Hermes agent. |
+
+All three talk to the same Moorcheh-backed Memanto agents, so memory written by
+one is recallable from the others when they share an `agent_id`.
+
+## Support
+
+- [Memanto Documentation](https://docs.memanto.ai)
+- [Moorcheh API Keys](https://console.moorcheh.ai/api-keys)
+- [Hermes agent](https://github.com/NousResearch/hermes-agent)

hermes_memanto-0.1.0/README.md

@@ -0,0 +1,122 @@
+# Hermes + Memanto: Persistent Memory Agent
+
+This package adds [Memanto](https://memanto.ai) as a **memory agent** for the
+[Hermes agent](https://github.com/NousResearch/hermes-agent). Memanto gives
+Hermes typed long-term memory with confidence and provenance, semantic recall,
+and RAG-style answers, backed by the [Moorcheh](https://moorcheh.ai) vector
+platform.
+
+Unlike a passive "memory layer", every namespace in Memanto is a first-class
+**agent** (`memanto agent create/activate`), so this provider maps one Hermes
+identity to one Memanto agent.
+
+## What you get
+
+- **Auto-recall** — relevant memories are injected before each turn.
+- **Turn capture** — conversation turns are stored as `event` memories.
+- **Explicit tools** — `memanto_remember`, `memanto_recall`, `memanto_answer`.
+- **Memory mirroring** — Hermes' built-in `memory` writes are echoed into Memanto.
+- **Profile isolation** — `agent_id: hermes-{identity}` scopes memory per Hermes profile.
+
+## Why a standalone plugin?
+
+Hermes' built-in providers under `plugins/memory/` are a closed set; new memory
+backends ship as standalone plugins that users install into
+`~/.hermes/plugins/`. Hermes discovers a memory provider as a **directory**
+under `$HERMES_HOME/plugins/<name>/` containing an `__init__.py` that exposes
+`register(ctx)` plus a `plugin.yaml`. This package ships exactly that, plus an
+installer that drops it into place.
+
+## Prerequisites
+
+- Python 3.10+
+- A running [Hermes agent](https://github.com/NousResearch/hermes-agent) install
+- A [Moorcheh API key](https://console.moorcheh.ai/api-keys) (free tier: 100K ops/month)
+
+## Install
+
+```bash
+# 1. Install this package (pulls in the memanto SDK)
+pip install hermes-memanto
+
+# 2. Drop the plugin into your Hermes home (~/.hermes/plugins/memanto/)
+hermes-memanto-install
+
+# 3. Configure your key + select the provider
+export MOORCHEH_API_KEY=...          # https://console.moorcheh.ai/api-keys
+hermes config set memory.provider memanto
+```
+
+`hermes memory setup` will also list **memanto** once the plugin is installed,
+and writes `MOORCHEH_API_KEY` into `~/.hermes/.env` for you.
+
+### From a source checkout
+
+```bash
+git clone https://github.com/moorcheh-ai/memanto.git
+cd memanto/integrations/hermes-agents
+pip install -e .
+hermes-memanto-install            # or: hermes-memanto-install --hermes-home /path/to/.hermes
+```
+
+The installer copies `hermes_memanto/provider.py` verbatim as the plugin's
+`__init__.py`, so the installed plugin is self-contained and only needs the
+`memanto` SDK at runtime (declared in its `plugin.yaml`).
+
+## Configuration
+
+After install, settings live in `$HERMES_HOME/memanto.json`:
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `agent_id` | `hermes-{identity}` | Memanto agent id (memory namespace). `{identity}` expands to the Hermes profile name. |
+| `pattern` | `tool` | Agent pattern used when auto-creating: `support`, `project`, or `tool`. |
+| `auto_recall` | `true` | Inject relevant memories before each turn. |
+| `auto_capture` | `true` | Store cleaned conversation turns as `event` memories. |
+| `auto_create` | `true` | Create the agent on first use if it does not exist. |
+| `mirror_memory_writes` | `true` | Echo Hermes' built-in `memory` writes into Memanto. |
+| `max_recall_results` | `10` | Max memories formatted into prefetch context (1–100). |
+| `min_confidence` | `null` | Drop recalled memories below this confidence (0.0–1.0). |
+| `session_duration_hours` | `null` | Override Memanto session lifetime. |
+
+| Environment variable | Description |
+|----------------------|-------------|
+| `MOORCHEH_API_KEY` | Moorcheh API key (required). |
+| `MEMANTO_AGENT_ID` | Override the agent id (takes priority over the config file). |
+
+## Tools exposed to Hermes
+
+| Tool | Description |
+|------|-------------|
+| `memanto_remember` | Store a durable fact, preference, decision, goal, or instruction. |
+| `memanto_recall` | Search memories by semantic similarity. |
+| `memanto_answer` | Answer a question grounded only in stored memories (RAG). |
+
+Memory types follow Memanto's taxonomy: `fact`, `preference`, `goal`,
+`decision`, `artifact`, `learning`, `event`, `instruction`, `relationship`,
+`context`, `observation`, `commitment`, `error`.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest          # provider unit tests (no network; SdkClient is faked)
+ruff check .
+```
+
+## How it relates to the other integrations
+
+| Integration | Package | What it does |
+|-------------|---------|--------------|
+| `integrations/mcp` | `memanto-mcp` | MCP server for any MCP-compatible client (Claude, Cursor). |
+| `integrations/crewai` | `crewai-memanto` | CrewAI tools for multi-agent memory sharing. |
+| `integrations/hermes-agents` | `hermes-memanto` | **This** — a memory provider for the Hermes agent. |
+
+All three talk to the same Moorcheh-backed Memanto agents, so memory written by
+one is recallable from the others when they share an `agent_id`.
+
+## Support
+
+- [Memanto Documentation](https://docs.memanto.ai)
+- [Moorcheh API Keys](https://console.moorcheh.ai/api-keys)
+- [Hermes agent](https://github.com/NousResearch/hermes-agent)

hermes_memanto-0.1.0/hermes_memanto/PLUGIN_README.md

@@ -0,0 +1,99 @@
+# Memanto Memory Agent Provider
+
+[Memanto](https://memanto.ai) is a **memory agent** — typed long-term memory with
+confidence and provenance, semantic recall, and RAG-style answers, backed by the
+[Moorcheh](https://moorcheh.ai) vector platform. Each Memanto namespace is a
+first-class *agent* (`memanto agent create/activate`), so this provider maps one
+Hermes identity to one Memanto agent.
+
+> This file lives inside the installed plugin directory
+> (`$HERMES_HOME/plugins/memanto/`). It was placed here by `hermes-memanto-install`.
+
+## Requirements
+
+- `pip install memanto`
+- Moorcheh API key from [console.moorcheh.ai/api-keys](https://console.moorcheh.ai/api-keys)
+
+## Setup
+
+```bash
+hermes memory setup    # select "memanto"
+```
+
+Or manually:
+
+```bash
+hermes config set memory.provider memanto
+echo 'MOORCHEH_API_KEY=***' >> ~/.hermes/.env
+```
+
+## Config
+
+Config file: `$HERMES_HOME/memanto.json`
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `agent_id` | `hermes-{identity}` | The Memanto agent id (memory namespace). Supports the `{identity}` template for per-profile scoping (e.g. `hermes-coder`). |
+| `pattern` | `tool` | Memanto agent pattern used when auto-creating: `support`, `project`, or `tool`. |
+| `auto_recall` | `true` | Inject relevant memories before each turn. |
+| `auto_capture` | `true` | Store cleaned user/assistant turns as `event` memories. |
+| `auto_create` | `true` | Create the agent on first use if it does not exist. |
+| `mirror_memory_writes` | `true` | Echo Hermes built-in `memory` writes into Memanto. |
+| `max_recall_results` | `10` | Max memories formatted into prefetch context (1–100). |
+| `min_confidence` | `null` | Drop recalled memories below this confidence (0.0–1.0). |
+| `session_duration_hours` | `null` | Override Memanto session lifetime (defaults to Memanto's config). |
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `MOORCHEH_API_KEY` | Moorcheh API key (required). |
+| `MEMANTO_AGENT_ID` | Override the agent id (takes priority over the config file). |
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `memanto_remember` | Store a durable fact, preference, decision, goal, or instruction. |
+| `memanto_recall` | Search memories by semantic similarity. |
+| `memanto_answer` | Answer a question grounded only in stored memories (RAG). |
+
+## Behavior
+
+When enabled, Hermes can:
+
+- prefetch relevant memories before each turn (`auto_recall`)
+- store cleaned conversation turns as `event` memories after each response (`auto_capture`)
+- mirror Hermes built-in `memory`/`user` writes into Memanto (`mirror_memory_writes`)
+- expose explicit `remember` / `recall` / `answer` tools
+
+Memory types follow Memanto's taxonomy: `fact`, `preference`, `goal`, `decision`,
+`artifact`, `learning`, `event`, `instruction`, `relationship`, `context`,
+`observation`, `commitment`, `error`.
+
+## Profile-Scoped Agents
+
+Use `{identity}` in `agent_id` to scope memories per Hermes profile:
+
+```json
+{
+  "agent_id": "hermes-{identity}"
+}
+```
+
+A profile named `coder` resolves to `hermes-coder`; the default profile resolves
+to `hermes-default`. Without `{identity}`, all profiles share one Memanto agent.
+
+## Notes
+
+- The session is warmed up (agent ensured + activated) in the background at
+  startup, so the first turn's recall does not also pay activation latency.
+- Writes are skipped in `cron`, `flush`, and `subagent` contexts to avoid
+  corrupting the user's memory representation.
+- Only one external memory provider runs at a time, selected via
+  `memory.provider` in `config.yaml`.
+
+## Support
+
+- [memanto.ai](https://memanto.ai)
+- [moorcheh.ai](https://moorcheh.ai)

hermes_memanto-0.1.0/hermes_memanto/__init__.py

@@ -0,0 +1,15 @@
+"""Memanto memory-agent provider for the Hermes agent.
+
+Install the directory plugin with the bundled console script::
+
+    hermes-memanto-install
+
+Then point Hermes at it::
+
+    hermes config set memory.provider memanto
+"""
+
+from hermes_memanto.provider import MemantoMemoryProvider, register
+
+__all__ = ["MemantoMemoryProvider", "register"]
+__version__ = "0.1.0"

hermes_memanto-0.1.0/hermes_memanto/install.py

@@ -0,0 +1,96 @@
+"""Install the Memanto plugin into a Hermes plugins directory.
+
+Hermes discovers memory providers as *directories* under
+``$HERMES_HOME/plugins/<name>/`` (default ``~/.hermes/plugins``), each holding
+an ``__init__.py`` that exposes ``register(ctx)`` plus a ``plugin.yaml``
+manifest. This script writes a self-contained ``memanto/`` plugin folder there
+by copying :mod:`hermes_memanto.provider` verbatim as the plugin's
+``__init__.py`` — so once installed it only needs the ``memanto`` SDK (declared
+in ``plugin.yaml``), not this package.
+
+Usage::
+
+    hermes-memanto-install                 # install into $HERMES_HOME (or ~/.hermes)
+    hermes-memanto-install --hermes-home /path/to/.hermes
+    hermes-memanto-install --force         # overwrite an existing install
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sys
+from pathlib import Path
+
+_PKG_DIR = Path(__file__).resolve().parent
+_PROVIDER_SRC = _PKG_DIR / "provider.py"
+_PLUGIN_YAML = _PKG_DIR / "plugin.yaml"
+_PLUGIN_README = _PKG_DIR / "PLUGIN_README.md"
+
+_PLUGIN_NAME = "memanto"
+
+
+def _default_hermes_home() -> Path:
+    env = os.environ.get("HERMES_HOME")
+    if env:
+        return Path(env).expanduser()
+    return Path.home() / ".hermes"
+
+
+def install(hermes_home: Path, *, force: bool = False) -> Path:
+    """Write the ``memanto`` plugin into ``hermes_home/plugins`` and return its path."""
+    target = hermes_home / "plugins" / _PLUGIN_NAME
+    if target.exists() and not force:
+        raise FileExistsError(
+            f"{target} already exists. Re-run with --force to overwrite it."
+        )
+    target.mkdir(parents=True, exist_ok=True)
+    # The provider module doubles as the plugin's __init__.py (it exposes
+    # register(ctx) and a MemantoMemoryProvider subclass).
+    shutil.copyfile(_PROVIDER_SRC, target / "__init__.py")
+    shutil.copyfile(_PLUGIN_YAML, target / "plugin.yaml")
+    if _PLUGIN_README.exists():
+        shutil.copyfile(_PLUGIN_README, target / "README.md")
+    return target
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="hermes-memanto-install",
+        description="Install the Memanto memory-agent plugin into Hermes.",
+    )
+    parser.add_argument(
+        "--hermes-home",
+        default=None,
+        help="Hermes home directory (default: $HERMES_HOME or ~/.hermes).",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite an existing memanto plugin.",
+    )
+    args = parser.parse_args(argv)
+
+    hermes_home = (
+        Path(args.hermes_home).expanduser()
+        if args.hermes_home
+        else _default_hermes_home()
+    )
+    try:
+        target = install(hermes_home, force=args.force)
+    except FileExistsError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+    print(f"Installed the Memanto memory plugin at {target}")
+    print("Next steps:")
+    print("  1. pip install memanto")
+    print("  2. export MOORCHEH_API_KEY=...   (https://console.moorcheh.ai/api-keys)")
+    print("  3. hermes config set memory.provider memanto")
+    print("     (or run: hermes memory setup  →  select 'memanto')")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

hermes_memanto-0.1.0/hermes_memanto/plugin.yaml

@@ -0,0 +1,5 @@
+name: memanto
+version: 0.1.0
+description: "Memanto memory agent — typed long-term memory (remember/recall/answer) backed by Moorcheh, with auto-recall, turn capture, and RAG."
+pip_dependencies:
+  - memanto>=0.1.0