Memwyre
/ PRODUCTS / PLUGINS
[1/3]

Your AI knowsyour project.

Memwyre plugins for Claude Code, OpenClaw, OpenCode, and Hermes Agent. One-click memory save, automatic context injection, and project-scoped knowledge.

Get Developer Plugins → View Documentation
📁 workspace-root/
├── 📁 src/
├── 📁 .memwyre/
└── 📄 project-scope.db (Indexed!)
🚀
Project Scoping
Auto-filters memory query by directory scope
The Disconnect

Every AI tool starts from zero.

01 . PROBLEM

No Project Memory

AI agents operate strictly on local context directories. They forget historical debugging runs and architecture decisions.

02 . PROBLEM

Repeated Explanations

Developers waste time repeatedly explaining libraries version mismatches, build requirements, and codebase conventions.

03 . PROBLEM

Isolated Tooling

Conversations remain locked within client histories. Your team cannot reuse the insights gained in Claude Code.

Plugin Specs

Install once. Remember forever.

1

Add config parameters

Configure the Memwyre plugin under plugins.entries.openclaw-plugin in openclaw.json with your key (starts with bv_sk_).

2

Semantic Loop Protection

The plugin tracks queries and intercepts duplicate searches, preventing LLM agents from entering infinite query loops.

3

Prompt Sanitization

Automatically strips reasoning, thought, and role tags from context streams to prevent agent message parser crashes.

openclaw.jsonJSON
{
  "plugins": {
    "entries": {
      "openclaw-plugin": {
        "enabled": true,
        "config": {
          "apiKey": "bv_sk_your_api_key_here",
          "hostUrl": "https://server.memwyre.tech"
        }
      }
    }
  }
}
Ecosystem

Built for the tools you love.

Claude Code
Claude Code

Auto-inject command line prompts & error summaries

✔ plugin active
OpenClaw
OpenClaw

Autonomous memory hooks for multi-agent workflows

✔ plugin active
OpenCode

Shared coding patterns & architecture conventions

✔ plugin active
Hermes Agent

Secure local-first knowledge extraction & scoping

✔ plugin active
Integration Details

Technical specifications of our developer plugins.

Memwyre developer plugins extend your command-line and agent environments by hooking directly into their execution cycles. For CLI tools like Claude Code, the integration exposes shell hooks that run before a command executes (pre-command hook) and after it exits (post-command hook). This allows the plugin to automatically capture error outputs, build files, and command history, streaming them into your memory vault as structured entries without requiring manual copy-pasting.

For autonomous frameworks such as OpenClaw, the plugin implements a persistent memory provider. As the agent plans and executes tasks, it queries the memory graph via vector semantic matching to retrieve relevant historical insights, while writing new learnings back to the graph. This creates a stateful workspace where agents can build upon work done in previous runs.

To prevent LLM context-window exhaustion and optimize token usage, the plugin uses a client-side filter. It dynamically selects and injects only the most relevant style rules, environment variables, and codebase paths based on the current task's scope. All interactions are signed using your developer API token, securing the connection between local CLI agents and your private cloud memory.

In IDE environments like VS Code and Cursor, the plugins run in the editor background, subscribing to active buffer state updates. When you open a file or start editing a line, the plugin extracts import statements and class definitions, querying your vault for related documentation pages. This allows the AI assistant to automatically suggest correct parameters or identify deprecated functions based on past debugging sessions stored in your vault. This real-time suggestion model boosts developer velocity.

All remote server interactions are authenticated via standard API keys that you can generate and rotate within the settings tab. The plugin client library maintains an offline-first storage queue; if your network connection drops, tool calls and saved memories are queued locally and synchronized automatically once the connection is restored, ensuring zero interruption in developer workflows. This local persistence queue makes the system fully reliable, resilient to network drops, and highly secure.

Context infrastructure for AI agents.

Give your AI agents a persistent long-term memory. Setup plugins in under 5 minutes.

Get Developer Plugins